Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 1 | // 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 Cross | 635c3b0 | 2016-05-18 15:37:25 -0700 | [diff] [blame] | 15 | package android |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 16 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 17 | // This is the primary location to write and read all configuration values and |
| 18 | // product variables necessary for soong_build's operation. |
| 19 | |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 20 | import ( |
Cole Faust | 082c5f3 | 2022-08-04 15:49:20 -0700 | [diff] [blame] | 21 | "bytes" |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 22 | "encoding/json" |
| 23 | "fmt" |
| 24 | "os" |
Colin Cross | 35cec12 | 2015-04-02 14:37:16 -0700 | [diff] [blame] | 25 | "path/filepath" |
Sam Delmerico | 5c32bbf | 2022-01-20 20:15:02 +0000 | [diff] [blame] | 26 | "reflect" |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 27 | "runtime" |
Inseob Kim | 60c32f0 | 2020-12-21 22:53:05 +0900 | [diff] [blame] | 28 | "strconv" |
Dan Willemsen | 34cc69e | 2015-09-23 15:26:20 -0700 | [diff] [blame] | 29 | "strings" |
Colin Cross | c1e86a3 | 2015-04-15 12:33:28 -0700 | [diff] [blame] | 30 | "sync" |
Colin Cross | 6ff5138 | 2015-12-17 16:39:19 -0800 | [diff] [blame] | 31 | |
Colin Cross | 98be1bb | 2019-12-13 20:41:13 -0800 | [diff] [blame] | 32 | "github.com/google/blueprint" |
Colin Cross | e87040b | 2017-12-11 15:52:26 -0800 | [diff] [blame] | 33 | "github.com/google/blueprint/bootstrap" |
Colin Cross | 98be1bb | 2019-12-13 20:41:13 -0800 | [diff] [blame] | 34 | "github.com/google/blueprint/pathtools" |
Colin Cross | 6ff5138 | 2015-12-17 16:39:19 -0800 | [diff] [blame] | 35 | "github.com/google/blueprint/proptools" |
Colin Cross | 9d34f35 | 2019-11-22 16:03:51 -0800 | [diff] [blame] | 36 | |
| 37 | "android/soong/android/soongconfig" |
Liz Kammer | 09f947d | 2021-05-12 14:51:49 -0400 | [diff] [blame] | 38 | "android/soong/bazel" |
Colin Cross | 77cdcfd | 2021-03-12 11:28:25 -0800 | [diff] [blame] | 39 | "android/soong/remoteexec" |
Liz Kammer | 72beb34 | 2022-02-03 08:42:10 -0500 | [diff] [blame] | 40 | "android/soong/starlark_fmt" |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 41 | ) |
| 42 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 43 | // Bool re-exports proptools.Bool for the android package. |
Colin Cross | 6ff5138 | 2015-12-17 16:39:19 -0800 | [diff] [blame] | 44 | var Bool = proptools.Bool |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 45 | |
| 46 | // String re-exports proptools.String for the android package. |
Jack He | 8cc7143 | 2016-12-08 15:45:07 -0800 | [diff] [blame] | 47 | var String = proptools.String |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 48 | |
| 49 | // StringDefault re-exports proptools.StringDefault for the android package. |
Jeongik Cha | 219141c | 2020-08-06 23:00:37 +0900 | [diff] [blame] | 50 | var StringDefault = proptools.StringDefault |
Jiyong Park | 6a927c4 | 2020-01-21 02:03:43 +0900 | [diff] [blame] | 51 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 52 | // FutureApiLevelInt is a placeholder constant for unreleased API levels. |
Dan Albert | 0b176c8 | 2020-07-23 16:43:25 -0700 | [diff] [blame] | 53 | const FutureApiLevelInt = 10000 |
| 54 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 55 | // FutureApiLevel represents unreleased API levels. |
Dan Albert | 0b176c8 | 2020-07-23 16:43:25 -0700 | [diff] [blame] | 56 | var FutureApiLevel = ApiLevel{ |
| 57 | value: "current", |
| 58 | number: FutureApiLevelInt, |
| 59 | isPreview: true, |
| 60 | } |
Colin Cross | 6ff5138 | 2015-12-17 16:39:19 -0800 | [diff] [blame] | 61 | |
Jingwen Chen | c4d91bc | 2020-11-24 22:59:26 -0500 | [diff] [blame] | 62 | // The product variables file name, containing product config from Kati. |
Dan Willemsen | 87b17d1 | 2015-07-14 00:39:06 -0700 | [diff] [blame] | 63 | const productVariablesFileName = "soong.variables" |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 64 | |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 65 | // A Config object represents the entire build configuration for Android. |
Colin Cross | c3c0a49 | 2015-04-10 15:43:55 -0700 | [diff] [blame] | 66 | type Config struct { |
| 67 | *config |
| 68 | } |
| 69 | |
Chris Parsons | ad87601 | 2022-08-20 14:48:32 -0400 | [diff] [blame] | 70 | type SoongBuildMode int |
| 71 | |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 72 | type CmdArgs struct { |
| 73 | bootstrap.Args |
| 74 | RunGoTests bool |
| 75 | OutDir string |
| 76 | SoongOutDir string |
| 77 | |
| 78 | SymlinkForestMarker string |
| 79 | Bp2buildMarker string |
| 80 | BazelQueryViewDir string |
| 81 | BazelApiBp2buildDir string |
| 82 | ModuleGraphFile string |
| 83 | ModuleActionsFile string |
| 84 | DocFile string |
| 85 | |
| 86 | BazelMode bool |
| 87 | BazelModeDev bool |
| 88 | BazelModeStaging bool |
| 89 | BazelForceEnabledModules string |
| 90 | } |
| 91 | |
Chris Parsons | ad87601 | 2022-08-20 14:48:32 -0400 | [diff] [blame] | 92 | // Build modes that soong_build can run as. |
| 93 | const ( |
| 94 | // Don't use bazel at all during module analysis. |
| 95 | AnalysisNoBazel SoongBuildMode = iota |
| 96 | |
Lukacs T. Berki | c541cd2 | 2022-10-26 07:26:50 +0000 | [diff] [blame] | 97 | // Symlink fores mode: merge two directory trees into a symlink forest |
| 98 | SymlinkForest |
| 99 | |
Chris Parsons | ad87601 | 2022-08-20 14:48:32 -0400 | [diff] [blame] | 100 | // Bp2build mode: Generate BUILD files from blueprint files and exit. |
| 101 | Bp2build |
| 102 | |
| 103 | // Generate BUILD files which faithfully represent the dependency graph of |
| 104 | // blueprint modules. Individual BUILD targets will not, however, faitfhully |
| 105 | // express build semantics. |
| 106 | GenerateQueryView |
| 107 | |
Spandan Das | 5af0bd3 | 2022-09-28 20:43:08 +0000 | [diff] [blame] | 108 | // Generate BUILD files for API contributions to API surfaces |
| 109 | ApiBp2build |
| 110 | |
Chris Parsons | ad87601 | 2022-08-20 14:48:32 -0400 | [diff] [blame] | 111 | // Create a JSON representation of the module graph and exit. |
| 112 | GenerateModuleGraph |
| 113 | |
| 114 | // Generate a documentation file for module type definitions and exit. |
| 115 | GenerateDocFile |
| 116 | |
| 117 | // Use bazel during analysis of many allowlisted build modules. The allowlist |
| 118 | // is considered a "developer mode" allowlist, as some modules may be |
| 119 | // allowlisted on an experimental basis. |
| 120 | BazelDevMode |
| 121 | |
MarkDacek | b78465d | 2022-10-18 20:10:16 +0000 | [diff] [blame] | 122 | // Use bazel during analysis of a few allowlisted build modules. The allowlist |
| 123 | // is considered "staging, as these are modules being prepared to be released |
| 124 | // into prod mode shortly after. |
| 125 | BazelStagingMode |
| 126 | |
Chris Parsons | ad87601 | 2022-08-20 14:48:32 -0400 | [diff] [blame] | 127 | // Use bazel during analysis of build modules from an allowlist carefully |
| 128 | // curated by the build team to be proven stable. |
Chris Parsons | ad87601 | 2022-08-20 14:48:32 -0400 | [diff] [blame] | 129 | BazelProdMode |
| 130 | ) |
| 131 | |
Lukacs T. Berki | b078ade | 2021-08-31 10:42:08 +0200 | [diff] [blame] | 132 | // SoongOutDir returns the build output directory for the configuration. |
Lukacs T. Berki | 9f6c24a | 2021-08-26 15:07:24 +0200 | [diff] [blame] | 133 | func (c Config) SoongOutDir() string { |
| 134 | return c.soongOutDir |
Jeff Gaston | efc1b41 | 2017-03-29 17:29:06 -0700 | [diff] [blame] | 135 | } |
| 136 | |
Lukacs T. Berki | 9f6c24a | 2021-08-26 15:07:24 +0200 | [diff] [blame] | 137 | func (c Config) OutDir() string { |
Lukacs T. Berki | d6cee7e | 2021-09-01 16:25:51 +0200 | [diff] [blame] | 138 | return c.outDir |
Lukacs T. Berki | 89e9a16 | 2021-03-12 08:31:32 +0100 | [diff] [blame] | 139 | } |
| 140 | |
Lukacs T. Berki | ea1a31c | 2021-09-02 09:58:09 +0200 | [diff] [blame] | 141 | func (c Config) RunGoTests() bool { |
| 142 | return c.runGoTests |
| 143 | } |
| 144 | |
Lukacs T. Berki | 5f6cb1d | 2021-03-17 15:03:14 +0100 | [diff] [blame] | 145 | func (c Config) DebugCompilation() bool { |
| 146 | return false // Never compile Go code in the main build for debugging |
| 147 | } |
| 148 | |
Lukacs T. Berki | ea1a31c | 2021-09-02 09:58:09 +0200 | [diff] [blame] | 149 | func (c Config) Subninjas() []string { |
| 150 | return []string{} |
| 151 | } |
| 152 | |
| 153 | func (c Config) PrimaryBuilderInvocations() []bootstrap.PrimaryBuilderInvocation { |
| 154 | return []bootstrap.PrimaryBuilderInvocation{} |
| 155 | } |
| 156 | |
Paul Duffin | 7413558 | 2022-10-06 11:01:59 +0100 | [diff] [blame] | 157 | // RunningInsideUnitTest returns true if this code is being run as part of a Soong unit test. |
| 158 | func (c Config) RunningInsideUnitTest() bool { |
| 159 | return c.config.TestProductVariables != nil |
| 160 | } |
| 161 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 162 | // A DeviceConfig object represents the configuration for a particular device |
| 163 | // being built. For now there will only be one of these, but in the future there |
| 164 | // may be multiple devices being built. |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 165 | type DeviceConfig struct { |
| 166 | *deviceConfig |
| 167 | } |
| 168 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 169 | // VendorConfig represents the configuration for vendor-specific behavior. |
Colin Cross | 9d34f35 | 2019-11-22 16:03:51 -0800 | [diff] [blame] | 170 | type VendorConfig soongconfig.SoongConfig |
Dan Willemsen | 0fe7866 | 2018-03-26 12:41:18 -0700 | [diff] [blame] | 171 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 172 | // Definition of general build configuration for soong_build. Some of these |
Jingwen Chen | c4d91bc | 2020-11-24 22:59:26 -0500 | [diff] [blame] | 173 | // product configuration values are read from Kati-generated soong.variables. |
Colin Cross | 1332b00 | 2015-04-07 17:11:30 -0700 | [diff] [blame] | 174 | type config struct { |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 175 | // Options configurable with soong.variables |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 176 | productVariables productVariables |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 177 | |
Dan Willemsen | 674dc7f | 2018-03-12 18:06:05 -0700 | [diff] [blame] | 178 | // Only available on configs created by TestConfig |
| 179 | TestProductVariables *productVariables |
| 180 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 181 | // A specialized context object for Bazel/Soong mixed builds and migration |
| 182 | // purposes. |
Chris Parsons | f3c96ef | 2020-09-29 02:23:17 -0400 | [diff] [blame] | 183 | BazelContext BazelContext |
| 184 | |
Dan Willemsen | 87b17d1 | 2015-07-14 00:39:06 -0700 | [diff] [blame] | 185 | ProductVariablesFileName string |
| 186 | |
Colin Cross | 0c66bc6 | 2021-07-20 09:47:41 -0700 | [diff] [blame] | 187 | // BuildOS stores the OsType for the OS that the build is running on. |
| 188 | BuildOS OsType |
| 189 | |
| 190 | // BuildArch stores the ArchType for the CPU that the build is running on. |
| 191 | BuildArch ArchType |
| 192 | |
Jaewoong Jung | 642916f | 2020-10-09 17:25:15 -0700 | [diff] [blame] | 193 | Targets map[OsType][]Target |
| 194 | BuildOSTarget Target // the Target for tools run on the build machine |
| 195 | BuildOSCommonTarget Target // the Target for common (java) tools run on the build machine |
| 196 | AndroidCommonTarget Target // the Target for common modules for the Android device |
| 197 | AndroidFirstDeviceTarget Target // the first Target for modules for the Android device |
Dan Willemsen | 218f656 | 2015-07-08 18:13:11 -0700 | [diff] [blame] | 198 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 199 | // multilibConflicts for an ArchType is true if there is earlier configured |
| 200 | // device architecture with the same multilib value. |
Colin Cross | 3b19f5d | 2019-09-17 14:45:31 -0700 | [diff] [blame] | 201 | multilibConflicts map[ArchType]bool |
| 202 | |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 203 | deviceConfig *deviceConfig |
| 204 | |
Lukacs T. Berki | d6cee7e | 2021-09-01 16:25:51 +0200 | [diff] [blame] | 205 | outDir string // The output directory (usually out/) |
| 206 | soongOutDir string |
Chris Parsons | 8f232a2 | 2020-06-23 17:37:05 -0400 | [diff] [blame] | 207 | moduleListFile string // the path to the file which lists blueprint files to parse. |
Colin Cross | c1e86a3 | 2015-04-15 12:33:28 -0700 | [diff] [blame] | 208 | |
Lukacs T. Berki | e1df43f | 2021-09-08 15:31:14 +0200 | [diff] [blame] | 209 | runGoTests bool |
Lukacs T. Berki | ea1a31c | 2021-09-02 09:58:09 +0200 | [diff] [blame] | 210 | |
Colin Cross | 6ccbc91 | 2017-10-10 23:07:38 -0700 | [diff] [blame] | 211 | env map[string]string |
Dan Willemsen | e7680ba | 2015-09-11 17:06:19 -0700 | [diff] [blame] | 212 | envLock sync.Mutex |
| 213 | envDeps map[string]string |
| 214 | envFrozen bool |
Dan Willemsen | 5ba07e8 | 2015-12-11 13:51:06 -0800 | [diff] [blame] | 215 | |
Jingwen Chen | cda22c9 | 2020-11-23 00:22:30 -0500 | [diff] [blame] | 216 | // Changes behavior based on whether Kati runs after soong_build, or if soong_build |
| 217 | // runs standalone. |
| 218 | katiEnabled bool |
Colin Cross | 1e7d370 | 2016-08-24 15:25:47 -0700 | [diff] [blame] | 219 | |
Colin Cross | 32616ed | 2017-09-05 21:56:44 -0700 | [diff] [blame] | 220 | captureBuild bool // true for tests, saves build parameters for each module |
| 221 | ignoreEnvironment bool // true for tests, returns empty from all Getenv calls |
Colin Cross | cec8171 | 2017-07-13 14:43:27 -0700 | [diff] [blame] | 222 | |
Colin Cross | 98be1bb | 2019-12-13 20:41:13 -0800 | [diff] [blame] | 223 | fs pathtools.FileSystem |
| 224 | mockBpList string |
| 225 | |
Chris Parsons | ad87601 | 2022-08-20 14:48:32 -0400 | [diff] [blame] | 226 | BuildMode SoongBuildMode |
Cole Faust | 324a92e | 2022-08-23 15:29:05 -0700 | [diff] [blame] | 227 | Bp2buildPackageConfig Bp2BuildConversionAllowlist |
Jingwen Chen | 0181202 | 2021-11-19 14:29:43 +0000 | [diff] [blame] | 228 | Bp2buildSoongConfigDefinitions soongconfig.Bp2BuildSoongConfigDefinitions |
Jingwen Chen | 12b4c27 | 2021-03-10 02:05:59 -0500 | [diff] [blame] | 229 | |
Colin Cross | 5e6a797 | 2020-06-07 16:56:32 -0700 | [diff] [blame] | 230 | // If testAllowNonExistentPaths is true then PathForSource and PathForModuleSrc won't error |
| 231 | // in tests when a path doesn't exist. |
Pedro Loureiro | 5d190cc | 2021-02-15 15:41:33 +0000 | [diff] [blame] | 232 | TestAllowNonExistentPaths bool |
Colin Cross | 5e6a797 | 2020-06-07 16:56:32 -0700 | [diff] [blame] | 233 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 234 | // The list of files that when changed, must invalidate soong_build to |
| 235 | // regenerate build.ninja. |
Colin Cross | 1212929 | 2020-10-29 18:23:58 -0700 | [diff] [blame] | 236 | ninjaFileDepsSet sync.Map |
| 237 | |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 238 | OncePer |
MarkDacek | ff851b8 | 2022-04-21 18:33:17 +0000 | [diff] [blame] | 239 | |
Chris Parsons | ad87601 | 2022-08-20 14:48:32 -0400 | [diff] [blame] | 240 | // These fields are only used for metrics collection. A module should be added |
| 241 | // to these maps only if its implementation supports Bazel handling in mixed |
| 242 | // builds. A module being in the "enabled" list indicates that there is a |
| 243 | // variant of that module for which bazel-handling actually took place. |
| 244 | // A module being in the "disabled" list indicates that there is a variant of |
| 245 | // that module for which bazel-handling was denied. |
MarkDacek | ff851b8 | 2022-04-21 18:33:17 +0000 | [diff] [blame] | 246 | mixedBuildsLock sync.Mutex |
| 247 | mixedBuildEnabledModules map[string]struct{} |
| 248 | mixedBuildDisabledModules map[string]struct{} |
MarkDacek | d06db5d | 2022-11-29 00:47:59 +0000 | [diff] [blame] | 249 | |
| 250 | // These are modules to be built with Bazel beyond the allowlisted/build-mode |
| 251 | // specified modules. They are passed via the command-line flag |
| 252 | // "--bazel-force-enabled-modules" |
| 253 | bazelForceEnabledModules map[string]struct{} |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 254 | } |
| 255 | |
| 256 | type deviceConfig struct { |
Dan Willemsen | 00269f2 | 2017-07-06 16:59:48 -0700 | [diff] [blame] | 257 | config *config |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 258 | OncePer |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 259 | } |
| 260 | |
Colin Cross | 485e572 | 2015-08-27 13:28:01 -0700 | [diff] [blame] | 261 | type jsonConfigurable interface { |
Colin Cross | 2738597 | 2015-09-18 10:57:10 -0700 | [diff] [blame] | 262 | SetDefaultConfig() |
Colin Cross | 485e572 | 2015-08-27 13:28:01 -0700 | [diff] [blame] | 263 | } |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 264 | |
Colin Cross | 485e572 | 2015-08-27 13:28:01 -0700 | [diff] [blame] | 265 | func loadConfig(config *config) error { |
Colin Cross | 988414c | 2020-01-11 01:11:46 +0000 | [diff] [blame] | 266 | return loadFromConfigFile(&config.productVariables, absolutePath(config.ProductVariablesFileName)) |
Colin Cross | 485e572 | 2015-08-27 13:28:01 -0700 | [diff] [blame] | 267 | } |
| 268 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 269 | // loadFromConfigFile loads and decodes configuration options from a JSON file |
| 270 | // in the current working directory. |
Liz Kammer | 09f947d | 2021-05-12 14:51:49 -0400 | [diff] [blame] | 271 | func loadFromConfigFile(configurable *productVariables, filename string) error { |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 272 | // Try to open the file |
Colin Cross | 485e572 | 2015-08-27 13:28:01 -0700 | [diff] [blame] | 273 | configFileReader, err := os.Open(filename) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 274 | defer configFileReader.Close() |
| 275 | if os.IsNotExist(err) { |
| 276 | // Need to create a file, so that blueprint & ninja don't get in |
| 277 | // a dependency tracking loop. |
| 278 | // Make a file-configurable-options with defaults, write it out using |
| 279 | // a json writer. |
Colin Cross | 2738597 | 2015-09-18 10:57:10 -0700 | [diff] [blame] | 280 | configurable.SetDefaultConfig() |
| 281 | err = saveToConfigFile(configurable, filename) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 282 | if err != nil { |
| 283 | return err |
| 284 | } |
Colin Cross | 15cd21a | 2018-02-27 11:26:02 -0800 | [diff] [blame] | 285 | } else if err != nil { |
| 286 | return fmt.Errorf("config file: could not open %s: %s", filename, err.Error()) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 287 | } else { |
| 288 | // Make a decoder for it |
| 289 | jsonDecoder := json.NewDecoder(configFileReader) |
Colin Cross | 485e572 | 2015-08-27 13:28:01 -0700 | [diff] [blame] | 290 | err = jsonDecoder.Decode(configurable) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 291 | if err != nil { |
Colin Cross | 15cd21a | 2018-02-27 11:26:02 -0800 | [diff] [blame] | 292 | return fmt.Errorf("config file: %s did not parse correctly: %s", filename, err.Error()) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 293 | } |
| 294 | } |
| 295 | |
Liz Kammer | 09f947d | 2021-05-12 14:51:49 -0400 | [diff] [blame] | 296 | if Bool(configurable.GcovCoverage) && Bool(configurable.ClangCoverage) { |
| 297 | return fmt.Errorf("GcovCoverage and ClangCoverage cannot both be set") |
| 298 | } |
| 299 | |
| 300 | configurable.Native_coverage = proptools.BoolPtr( |
| 301 | Bool(configurable.GcovCoverage) || |
| 302 | Bool(configurable.ClangCoverage)) |
| 303 | |
Yuntao Xu | 402e9b0 | 2021-08-09 15:44:44 -0700 | [diff] [blame] | 304 | // when Platform_sdk_final is true (or PLATFORM_VERSION_CODENAME is REL), use Platform_sdk_version; |
| 305 | // if false (pre-released version, for example), use Platform_sdk_codename. |
| 306 | if Bool(configurable.Platform_sdk_final) { |
| 307 | if configurable.Platform_sdk_version != nil { |
| 308 | configurable.Platform_sdk_version_or_codename = |
| 309 | proptools.StringPtr(strconv.Itoa(*(configurable.Platform_sdk_version))) |
| 310 | } else { |
| 311 | return fmt.Errorf("Platform_sdk_version cannot be pointed by a NULL pointer") |
| 312 | } |
| 313 | } else { |
| 314 | configurable.Platform_sdk_version_or_codename = |
| 315 | proptools.StringPtr(String(configurable.Platform_sdk_codename)) |
| 316 | } |
| 317 | |
Liz Kammer | 09f947d | 2021-05-12 14:51:49 -0400 | [diff] [blame] | 318 | return saveToBazelConfigFile(configurable, filepath.Dir(filename)) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 319 | } |
| 320 | |
Colin Cross | d8f2014 | 2016-11-03 09:43:26 -0700 | [diff] [blame] | 321 | // atomically writes the config file in case two copies of soong_build are running simultaneously |
| 322 | // (for example, docs generation and ninja manifest generation) |
Liz Kammer | 09f947d | 2021-05-12 14:51:49 -0400 | [diff] [blame] | 323 | func saveToConfigFile(config *productVariables, filename string) error { |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 324 | data, err := json.MarshalIndent(&config, "", " ") |
| 325 | if err != nil { |
| 326 | return fmt.Errorf("cannot marshal config data: %s", err.Error()) |
| 327 | } |
| 328 | |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 329 | f, err := os.CreateTemp(filepath.Dir(filename), "config") |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 330 | if err != nil { |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 331 | return fmt.Errorf("cannot create empty config file %s: %s", filename, err.Error()) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 332 | } |
Colin Cross | d8f2014 | 2016-11-03 09:43:26 -0700 | [diff] [blame] | 333 | defer os.Remove(f.Name()) |
| 334 | defer f.Close() |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 335 | |
Colin Cross | d8f2014 | 2016-11-03 09:43:26 -0700 | [diff] [blame] | 336 | _, err = f.Write(data) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 337 | if err != nil { |
Colin Cross | 485e572 | 2015-08-27 13:28:01 -0700 | [diff] [blame] | 338 | return fmt.Errorf("default config file: %s could not be written: %s", filename, err.Error()) |
| 339 | } |
| 340 | |
Colin Cross | d8f2014 | 2016-11-03 09:43:26 -0700 | [diff] [blame] | 341 | _, err = f.WriteString("\n") |
Colin Cross | 485e572 | 2015-08-27 13:28:01 -0700 | [diff] [blame] | 342 | if err != nil { |
| 343 | return fmt.Errorf("default config file: %s could not be written: %s", filename, err.Error()) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 344 | } |
| 345 | |
Colin Cross | d8f2014 | 2016-11-03 09:43:26 -0700 | [diff] [blame] | 346 | f.Close() |
| 347 | os.Rename(f.Name(), filename) |
| 348 | |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 349 | return nil |
| 350 | } |
| 351 | |
Liz Kammer | 09f947d | 2021-05-12 14:51:49 -0400 | [diff] [blame] | 352 | func saveToBazelConfigFile(config *productVariables, outDir string) error { |
| 353 | dir := filepath.Join(outDir, bazel.SoongInjectionDirName, "product_config") |
| 354 | err := createDirIfNonexistent(dir, os.ModePerm) |
| 355 | if err != nil { |
| 356 | return fmt.Errorf("Could not create dir %s: %s", dir, err) |
| 357 | } |
| 358 | |
Sam Delmerico | 5c32bbf | 2022-01-20 20:15:02 +0000 | [diff] [blame] | 359 | nonArchVariantProductVariables := []string{} |
| 360 | archVariantProductVariables := []string{} |
| 361 | p := variableProperties{} |
| 362 | t := reflect.TypeOf(p.Product_variables) |
| 363 | for i := 0; i < t.NumField(); i++ { |
| 364 | f := t.Field(i) |
| 365 | nonArchVariantProductVariables = append(nonArchVariantProductVariables, strings.ToLower(f.Name)) |
| 366 | if proptools.HasTag(f, "android", "arch_variant") { |
| 367 | archVariantProductVariables = append(archVariantProductVariables, strings.ToLower(f.Name)) |
| 368 | } |
| 369 | } |
| 370 | |
Liz Kammer | 72beb34 | 2022-02-03 08:42:10 -0500 | [diff] [blame] | 371 | nonArchVariantProductVariablesJson := starlark_fmt.PrintStringList(nonArchVariantProductVariables, 0) |
Sam Delmerico | 5c32bbf | 2022-01-20 20:15:02 +0000 | [diff] [blame] | 372 | if err != nil { |
| 373 | return fmt.Errorf("cannot marshal product variable data: %s", err.Error()) |
| 374 | } |
| 375 | |
Liz Kammer | 72beb34 | 2022-02-03 08:42:10 -0500 | [diff] [blame] | 376 | archVariantProductVariablesJson := starlark_fmt.PrintStringList(archVariantProductVariables, 0) |
Sam Delmerico | 5c32bbf | 2022-01-20 20:15:02 +0000 | [diff] [blame] | 377 | if err != nil { |
| 378 | return fmt.Errorf("cannot marshal arch variant product variable data: %s", err.Error()) |
| 379 | } |
| 380 | |
| 381 | configJson, err := json.MarshalIndent(&config, "", " ") |
Liz Kammer | 09f947d | 2021-05-12 14:51:49 -0400 | [diff] [blame] | 382 | if err != nil { |
| 383 | return fmt.Errorf("cannot marshal config data: %s", err.Error()) |
| 384 | } |
Cole Faust | 082c5f3 | 2022-08-04 15:49:20 -0700 | [diff] [blame] | 385 | // The backslashes need to be escaped because this text is going to be put |
| 386 | // inside a Starlark string literal. |
| 387 | configJson = bytes.ReplaceAll(configJson, []byte("\\"), []byte("\\\\")) |
Liz Kammer | 09f947d | 2021-05-12 14:51:49 -0400 | [diff] [blame] | 388 | |
| 389 | bzl := []string{ |
| 390 | bazel.GeneratedBazelFileWarning, |
Sam Delmerico | 5c32bbf | 2022-01-20 20:15:02 +0000 | [diff] [blame] | 391 | fmt.Sprintf(`_product_vars = json.decode("""%s""")`, configJson), |
| 392 | fmt.Sprintf(`_product_var_constraints = %s`, nonArchVariantProductVariablesJson), |
| 393 | fmt.Sprintf(`_arch_variant_product_var_constraints = %s`, archVariantProductVariablesJson), |
| 394 | "\n", ` |
| 395 | product_vars = _product_vars |
| 396 | product_var_constraints = _product_var_constraints |
| 397 | arch_variant_product_var_constraints = _arch_variant_product_var_constraints |
| 398 | `, |
Liz Kammer | 09f947d | 2021-05-12 14:51:49 -0400 | [diff] [blame] | 399 | } |
Chris Parsons | 0008cf8 | 2023-02-03 18:45:43 -0500 | [diff] [blame] | 400 | err = pathtools.WriteFileIfChanged(filepath.Join(dir, "product_variables.bzl"), |
| 401 | []byte(strings.Join(bzl, "\n")), 0644) |
Liz Kammer | 09f947d | 2021-05-12 14:51:49 -0400 | [diff] [blame] | 402 | if err != nil { |
| 403 | return fmt.Errorf("Could not write .bzl config file %s", err) |
| 404 | } |
Chris Parsons | 0008cf8 | 2023-02-03 18:45:43 -0500 | [diff] [blame] | 405 | err = pathtools.WriteFileIfChanged(filepath.Join(dir, "BUILD"), |
| 406 | []byte(bazel.GeneratedBazelFileWarning), 0644) |
Liz Kammer | 09f947d | 2021-05-12 14:51:49 -0400 | [diff] [blame] | 407 | if err != nil { |
| 408 | return fmt.Errorf("Could not write BUILD config file %s", err) |
| 409 | } |
| 410 | |
| 411 | return nil |
| 412 | } |
| 413 | |
Colin Cross | 988414c | 2020-01-11 01:11:46 +0000 | [diff] [blame] | 414 | // NullConfig returns a mostly empty Config for use by standalone tools like dexpreopt_gen that |
| 415 | // use the android package. |
Lukacs T. Berki | d6cee7e | 2021-09-01 16:25:51 +0200 | [diff] [blame] | 416 | func NullConfig(outDir, soongOutDir string) Config { |
Colin Cross | 988414c | 2020-01-11 01:11:46 +0000 | [diff] [blame] | 417 | return Config{ |
| 418 | config: &config{ |
Lukacs T. Berki | d6cee7e | 2021-09-01 16:25:51 +0200 | [diff] [blame] | 419 | outDir: outDir, |
Lukacs T. Berki | 9f6c24a | 2021-08-26 15:07:24 +0200 | [diff] [blame] | 420 | soongOutDir: soongOutDir, |
| 421 | fs: pathtools.OsFs, |
Colin Cross | 988414c | 2020-01-11 01:11:46 +0000 | [diff] [blame] | 422 | }, |
| 423 | } |
| 424 | } |
| 425 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 426 | // NewConfig creates a new Config object. The srcDir argument specifies the path |
| 427 | // to the root source directory. It also loads the config file, if found. |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 428 | func NewConfig(cmdArgs CmdArgs, availableEnv map[string]string) (Config, error) { |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 429 | // Make a config with default options. |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 430 | config := &config{ |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 431 | ProductVariablesFileName: filepath.Join(cmdArgs.SoongOutDir, productVariablesFileName), |
Dan Willemsen | 87b17d1 | 2015-07-14 00:39:06 -0700 | [diff] [blame] | 432 | |
Lukacs T. Berki | 53b2f36 | 2021-04-12 14:04:24 +0200 | [diff] [blame] | 433 | env: availableEnv, |
Colin Cross | 6ccbc91 | 2017-10-10 23:07:38 -0700 | [diff] [blame] | 434 | |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 435 | outDir: cmdArgs.OutDir, |
| 436 | soongOutDir: cmdArgs.SoongOutDir, |
| 437 | runGoTests: cmdArgs.RunGoTests, |
Lukacs T. Berki | e1df43f | 2021-09-08 15:31:14 +0200 | [diff] [blame] | 438 | multilibConflicts: make(map[ArchType]bool), |
Colin Cross | 98be1bb | 2019-12-13 20:41:13 -0800 | [diff] [blame] | 439 | |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 440 | moduleListFile: cmdArgs.ModuleListFile, |
MarkDacek | ff851b8 | 2022-04-21 18:33:17 +0000 | [diff] [blame] | 441 | fs: pathtools.NewOsFs(absSrcDir), |
| 442 | mixedBuildDisabledModules: make(map[string]struct{}), |
| 443 | mixedBuildEnabledModules: make(map[string]struct{}), |
MarkDacek | d06db5d | 2022-11-29 00:47:59 +0000 | [diff] [blame] | 444 | bazelForceEnabledModules: make(map[string]struct{}), |
Colin Cross | 68f5510 | 2015-03-25 14:43:57 -0700 | [diff] [blame] | 445 | } |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 446 | |
Dan Willemsen | 00269f2 | 2017-07-06 16:59:48 -0700 | [diff] [blame] | 447 | config.deviceConfig = &deviceConfig{ |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 448 | config: config, |
| 449 | } |
| 450 | |
Liz Kammer | 7941b30 | 2020-07-28 13:27:34 -0700 | [diff] [blame] | 451 | // Soundness check of the build and source directories. This won't catch strange |
| 452 | // configurations with symlinks, but at least checks the obvious case. |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 453 | absBuildDir, err := filepath.Abs(cmdArgs.SoongOutDir) |
Dan Willemsen | 34cc69e | 2015-09-23 15:26:20 -0700 | [diff] [blame] | 454 | if err != nil { |
| 455 | return Config{}, err |
| 456 | } |
| 457 | |
Lukacs T. Berki | f7e36d8 | 2021-08-16 17:05:09 +0200 | [diff] [blame] | 458 | absSrcDir, err := filepath.Abs(".") |
Dan Willemsen | 34cc69e | 2015-09-23 15:26:20 -0700 | [diff] [blame] | 459 | if err != nil { |
| 460 | return Config{}, err |
| 461 | } |
| 462 | |
| 463 | if strings.HasPrefix(absSrcDir, absBuildDir) { |
| 464 | return Config{}, fmt.Errorf("Build dir must not contain source directory") |
| 465 | } |
| 466 | |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 467 | // Load any configurable options from the configuration file |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 468 | err = loadConfig(config) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 469 | if err != nil { |
Colin Cross | c3c0a49 | 2015-04-10 15:43:55 -0700 | [diff] [blame] | 470 | return Config{}, err |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 471 | } |
| 472 | |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 473 | KatiEnabledMarkerFile := filepath.Join(cmdArgs.SoongOutDir, ".soong.kati_enabled") |
Jingwen Chen | cda22c9 | 2020-11-23 00:22:30 -0500 | [diff] [blame] | 474 | if _, err := os.Stat(absolutePath(KatiEnabledMarkerFile)); err == nil { |
| 475 | config.katiEnabled = true |
Dan Willemsen | 5ba07e8 | 2015-12-11 13:51:06 -0800 | [diff] [blame] | 476 | } |
| 477 | |
Colin Cross | 0c66bc6 | 2021-07-20 09:47:41 -0700 | [diff] [blame] | 478 | determineBuildOS(config) |
| 479 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 480 | // Sets up the map of target OSes to the finer grained compilation targets |
| 481 | // that are configured from the product variables. |
Colin Cross | a1ad8d1 | 2016-06-01 17:09:44 -0700 | [diff] [blame] | 482 | targets, err := decodeTargetProductVariables(config) |
Dan Willemsen | 218f656 | 2015-07-08 18:13:11 -0700 | [diff] [blame] | 483 | if err != nil { |
| 484 | return Config{}, err |
| 485 | } |
| 486 | |
Paul Duffin | 1356d8c | 2020-02-25 19:26:33 +0000 | [diff] [blame] | 487 | // Make the CommonOS OsType available for all products. |
| 488 | targets[CommonOS] = []Target{commonTargetMap[CommonOS.Name]} |
| 489 | |
Dan Albert | 4098deb | 2016-10-19 14:04:41 -0700 | [diff] [blame] | 490 | var archConfig []archConfig |
Jingwen Chen | c4d91bc | 2020-11-24 22:59:26 -0500 | [diff] [blame] | 491 | if config.NdkAbis() { |
Dan Albert | 4098deb | 2016-10-19 14:04:41 -0700 | [diff] [blame] | 492 | archConfig = getNdkAbisConfig() |
Martin Stjernholm | c1ecc43 | 2019-11-15 15:00:31 +0000 | [diff] [blame] | 493 | } else if config.AmlAbis() { |
| 494 | archConfig = getAmlAbisConfig() |
Dan Albert | 4098deb | 2016-10-19 14:04:41 -0700 | [diff] [blame] | 495 | } |
| 496 | |
| 497 | if archConfig != nil { |
Liz Kammer | b7f3366 | 2022-02-28 14:16:16 -0500 | [diff] [blame] | 498 | androidTargets, err := decodeAndroidArchSettings(archConfig) |
Dan Willemsen | 322acaf | 2016-01-12 23:07:05 -0800 | [diff] [blame] | 499 | if err != nil { |
| 500 | return Config{}, err |
| 501 | } |
Dan Willemsen | 0ef639b | 2018-10-10 17:02:29 -0700 | [diff] [blame] | 502 | targets[Android] = androidTargets |
Dan Willemsen | 322acaf | 2016-01-12 23:07:05 -0800 | [diff] [blame] | 503 | } |
| 504 | |
Colin Cross | 3b19f5d | 2019-09-17 14:45:31 -0700 | [diff] [blame] | 505 | multilib := make(map[string]bool) |
| 506 | for _, target := range targets[Android] { |
| 507 | if seen := multilib[target.Arch.ArchType.Multilib]; seen { |
| 508 | config.multilibConflicts[target.Arch.ArchType] = true |
| 509 | } |
| 510 | multilib[target.Arch.ArchType.Multilib] = true |
| 511 | } |
| 512 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 513 | // Map of OS to compilation targets. |
Colin Cross | a1ad8d1 | 2016-06-01 17:09:44 -0700 | [diff] [blame] | 514 | config.Targets = targets |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 515 | |
| 516 | // Compilation targets for host tools. |
Colin Cross | 0c66bc6 | 2021-07-20 09:47:41 -0700 | [diff] [blame] | 517 | config.BuildOSTarget = config.Targets[config.BuildOS][0] |
| 518 | config.BuildOSCommonTarget = getCommonTargets(config.Targets[config.BuildOS])[0] |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 519 | |
| 520 | // Compilation targets for Android. |
Colin Cross | 0f7d2ef | 2019-10-16 11:03:10 -0700 | [diff] [blame] | 521 | if len(config.Targets[Android]) > 0 { |
| 522 | config.AndroidCommonTarget = getCommonTargets(config.Targets[Android])[0] |
Sam Delmerico | cc271e2 | 2022-06-01 15:45:02 +0000 | [diff] [blame] | 523 | config.AndroidFirstDeviceTarget = FirstTarget(config.Targets[Android], "lib64", "lib32")[0] |
Colin Cross | 0f7d2ef | 2019-10-16 11:03:10 -0700 | [diff] [blame] | 524 | } |
Dan Willemsen | 218f656 | 2015-07-08 18:13:11 -0700 | [diff] [blame] | 525 | |
Usta Shrestha | cae3bfa | 2022-12-21 11:44:26 -0500 | [diff] [blame] | 526 | setBuildMode := func(arg string, mode SoongBuildMode) { |
| 527 | if arg != "" { |
| 528 | if config.BuildMode != AnalysisNoBazel { |
| 529 | fmt.Fprintf(os.Stderr, "buildMode is already set, illegal argument: %s", arg) |
| 530 | os.Exit(1) |
| 531 | } |
| 532 | config.BuildMode = mode |
| 533 | } |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 534 | } |
Usta Shrestha | cae3bfa | 2022-12-21 11:44:26 -0500 | [diff] [blame] | 535 | setBazelMode := func(arg bool, argName string, mode SoongBuildMode) { |
| 536 | if arg { |
| 537 | if config.BuildMode != AnalysisNoBazel { |
| 538 | fmt.Fprintf(os.Stderr, "buildMode is already set, illegal argument: %s", argName) |
| 539 | os.Exit(1) |
| 540 | } |
| 541 | config.BuildMode = mode |
| 542 | } |
| 543 | } |
| 544 | setBuildMode(cmdArgs.SymlinkForestMarker, SymlinkForest) |
| 545 | setBuildMode(cmdArgs.Bp2buildMarker, Bp2build) |
| 546 | setBuildMode(cmdArgs.BazelQueryViewDir, GenerateQueryView) |
| 547 | setBuildMode(cmdArgs.BazelApiBp2buildDir, ApiBp2build) |
| 548 | setBuildMode(cmdArgs.ModuleGraphFile, GenerateModuleGraph) |
| 549 | setBuildMode(cmdArgs.DocFile, GenerateDocFile) |
| 550 | setBazelMode(cmdArgs.BazelModeDev, "--bazel-mode-dev", BazelDevMode) |
| 551 | setBazelMode(cmdArgs.BazelMode, "--bazel-mode", BazelProdMode) |
| 552 | setBazelMode(cmdArgs.BazelModeStaging, "--bazel-mode-staging", BazelStagingMode) |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 553 | |
Chris Parsons | f3c96ef | 2020-09-29 02:23:17 -0400 | [diff] [blame] | 554 | config.BazelContext, err = NewBazelContext(config) |
Cole Faust | 324a92e | 2022-08-23 15:29:05 -0700 | [diff] [blame] | 555 | config.Bp2buildPackageConfig = GetBp2BuildAllowList() |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 556 | |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 557 | for _, module := range strings.Split(cmdArgs.BazelForceEnabledModules, ",") { |
MarkDacek | d06db5d | 2022-11-29 00:47:59 +0000 | [diff] [blame] | 558 | config.bazelForceEnabledModules[module] = struct{}{} |
| 559 | } |
| 560 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 561 | return Config{config}, err |
| 562 | } |
Colin Cross | 988414c | 2020-01-11 01:11:46 +0000 | [diff] [blame] | 563 | |
Colin Cross | 98be1bb | 2019-12-13 20:41:13 -0800 | [diff] [blame] | 564 | // mockFileSystem replaces all reads with accesses to the provided map of |
| 565 | // filenames to contents stored as a byte slice. |
| 566 | func (c *config) mockFileSystem(bp string, fs map[string][]byte) { |
| 567 | mockFS := map[string][]byte{} |
| 568 | |
| 569 | if _, exists := mockFS["Android.bp"]; !exists { |
| 570 | mockFS["Android.bp"] = []byte(bp) |
| 571 | } |
| 572 | |
| 573 | for k, v := range fs { |
| 574 | mockFS[k] = v |
| 575 | } |
| 576 | |
| 577 | // no module list file specified; find every file named Blueprints or Android.bp |
| 578 | pathsToParse := []string{} |
| 579 | for candidate := range mockFS { |
| 580 | base := filepath.Base(candidate) |
Lukacs T. Berki | b838b0a | 2021-09-02 11:46:24 +0200 | [diff] [blame] | 581 | if base == "Android.bp" { |
Colin Cross | 98be1bb | 2019-12-13 20:41:13 -0800 | [diff] [blame] | 582 | pathsToParse = append(pathsToParse, candidate) |
| 583 | } |
| 584 | } |
| 585 | if len(pathsToParse) < 1 { |
| 586 | panic(fmt.Sprintf("No Blueprint or Android.bp files found in mock filesystem: %v\n", mockFS)) |
| 587 | } |
| 588 | mockFS[blueprint.MockModuleListFile] = []byte(strings.Join(pathsToParse, "\n")) |
| 589 | |
| 590 | c.fs = pathtools.MockFs(mockFS) |
| 591 | c.mockBpList = blueprint.MockModuleListFile |
| 592 | } |
| 593 | |
Jason Wu | ff1bb31 | 2022-12-21 09:57:26 -0500 | [diff] [blame] | 594 | // TODO(b/265062549): Add a field to our collected (and uploaded) metrics which |
| 595 | // describes a reason that we fell back to non-mixed builds. |
Chris Parsons | ad87601 | 2022-08-20 14:48:32 -0400 | [diff] [blame] | 596 | // Returns true if "Bazel builds" is enabled. In this mode, part of build |
| 597 | // analysis is handled by Bazel. |
| 598 | func (c *config) IsMixedBuildsEnabled() bool { |
Chris Parsons | 428c30f | 2022-11-29 14:14:52 -0500 | [diff] [blame] | 599 | globalMixedBuildsSupport := c.Once(OnceKey{"globalMixedBuildsSupport"}, func() interface{} { |
| 600 | if c.productVariables.DeviceArch != nil && *c.productVariables.DeviceArch == "riscv64" { |
Chris Parsons | 428c30f | 2022-11-29 14:14:52 -0500 | [diff] [blame] | 601 | return false |
| 602 | } |
Sam Delmerico | 5150d0d | 2022-11-15 17:44:44 -0500 | [diff] [blame] | 603 | if c.IsEnvTrue("GLOBAL_THINLTO") { |
Sam Delmerico | 5150d0d | 2022-11-15 17:44:44 -0500 | [diff] [blame] | 604 | return false |
| 605 | } |
Sam Delmerico | 5150d0d | 2022-11-15 17:44:44 -0500 | [diff] [blame] | 606 | if len(c.productVariables.SanitizeHost) > 0 { |
Sam Delmerico | 5150d0d | 2022-11-15 17:44:44 -0500 | [diff] [blame] | 607 | return false |
| 608 | } |
| 609 | if len(c.productVariables.SanitizeDevice) > 0 { |
Sam Delmerico | 5150d0d | 2022-11-15 17:44:44 -0500 | [diff] [blame] | 610 | return false |
| 611 | } |
| 612 | if len(c.productVariables.SanitizeDeviceDiag) > 0 { |
Sam Delmerico | 5150d0d | 2022-11-15 17:44:44 -0500 | [diff] [blame] | 613 | return false |
| 614 | } |
| 615 | if len(c.productVariables.SanitizeDeviceArch) > 0 { |
Sam Delmerico | 5150d0d | 2022-11-15 17:44:44 -0500 | [diff] [blame] | 616 | return false |
| 617 | } |
Chris Parsons | 428c30f | 2022-11-29 14:14:52 -0500 | [diff] [blame] | 618 | return true |
| 619 | }).(bool) |
| 620 | |
| 621 | bazelModeEnabled := c.BuildMode == BazelProdMode || c.BuildMode == BazelDevMode || c.BuildMode == BazelStagingMode |
| 622 | return globalMixedBuildsSupport && bazelModeEnabled |
Chris Parsons | ad87601 | 2022-08-20 14:48:32 -0400 | [diff] [blame] | 623 | } |
| 624 | |
Lukacs T. Berki | d1e3f1f | 2021-03-16 08:55:23 +0100 | [diff] [blame] | 625 | func (c *config) SetAllowMissingDependencies() { |
| 626 | c.productVariables.Allow_missing_dependencies = proptools.BoolPtr(true) |
| 627 | } |
| 628 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 629 | // BlueprintToolLocation returns the directory containing build system tools |
| 630 | // from Blueprint, like soong_zip and merge_zips. |
Lukacs T. Berki | a806e41 | 2021-09-01 08:57:48 +0200 | [diff] [blame] | 631 | func (c *config) HostToolDir() string { |
Colin Cross | acfcc1f | 2021-10-25 15:40:32 -0700 | [diff] [blame] | 632 | if c.KatiEnabled() { |
| 633 | return filepath.Join(c.outDir, "host", c.PrebuiltOS(), "bin") |
| 634 | } else { |
| 635 | return filepath.Join(c.soongOutDir, "host", c.PrebuiltOS(), "bin") |
| 636 | } |
Dan Willemsen | c2aa4a9 | 2016-05-26 15:13:03 -0700 | [diff] [blame] | 637 | } |
| 638 | |
Dan Willemsen | 60e62f0 | 2018-11-16 21:05:32 -0800 | [diff] [blame] | 639 | func (c *config) HostToolPath(ctx PathContext, tool string) Path { |
Colin Cross | 790ef35 | 2021-10-25 19:15:55 -0700 | [diff] [blame] | 640 | path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "bin", false, tool) |
| 641 | return path |
Dan Willemsen | 60e62f0 | 2018-11-16 21:05:32 -0800 | [diff] [blame] | 642 | } |
| 643 | |
Colin Cross | 790ef35 | 2021-10-25 19:15:55 -0700 | [diff] [blame] | 644 | func (c *config) HostJNIToolPath(ctx PathContext, lib string) Path { |
Martin Stjernholm | 7260d06 | 2019-12-09 21:47:14 +0000 | [diff] [blame] | 645 | ext := ".so" |
| 646 | if runtime.GOOS == "darwin" { |
| 647 | ext = ".dylib" |
| 648 | } |
Colin Cross | 790ef35 | 2021-10-25 19:15:55 -0700 | [diff] [blame] | 649 | path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "lib64", false, lib+ext) |
| 650 | return path |
Martin Stjernholm | 7260d06 | 2019-12-09 21:47:14 +0000 | [diff] [blame] | 651 | } |
| 652 | |
Colin Cross | ae5330a | 2021-11-03 13:31:22 -0700 | [diff] [blame] | 653 | func (c *config) HostJavaToolPath(ctx PathContext, tool string) Path { |
| 654 | path := pathForInstall(ctx, ctx.Config().BuildOS, ctx.Config().BuildArch, "framework", false, tool) |
Colin Cross | 3e3eda6 | 2021-11-04 10:22:51 -0700 | [diff] [blame] | 655 | return path |
| 656 | } |
| 657 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 658 | // PrebuiltOS returns the name of the host OS used in prebuilts directories. |
Colin Cross | 1332b00 | 2015-04-07 17:11:30 -0700 | [diff] [blame] | 659 | func (c *config) PrebuiltOS() string { |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 660 | switch runtime.GOOS { |
| 661 | case "linux": |
| 662 | return "linux-x86" |
| 663 | case "darwin": |
| 664 | return "darwin-x86" |
| 665 | default: |
| 666 | panic("Unknown GOOS") |
| 667 | } |
| 668 | } |
| 669 | |
| 670 | // GoRoot returns the path to the root directory of the Go toolchain. |
Colin Cross | 1332b00 | 2015-04-07 17:11:30 -0700 | [diff] [blame] | 671 | func (c *config) GoRoot() string { |
Lukacs T. Berki | f7e36d8 | 2021-08-16 17:05:09 +0200 | [diff] [blame] | 672 | return fmt.Sprintf("prebuilts/go/%s", c.PrebuiltOS()) |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 673 | } |
| 674 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 675 | // PrebuiltBuildTool returns the path to a tool in the prebuilts directory containing |
| 676 | // checked-in tools, like Kati, Ninja or Toybox, for the current host OS. |
Dan Willemsen | 4e0aa23 | 2019-04-10 22:59:54 -0700 | [diff] [blame] | 677 | func (c *config) PrebuiltBuildTool(ctx PathContext, tool string) Path { |
| 678 | return PathForSource(ctx, "prebuilts/build-tools", c.PrebuiltOS(), "bin", tool) |
| 679 | } |
| 680 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 681 | // CpPreserveSymlinksFlags returns the host-specific flag for the cp(1) command |
| 682 | // to preserve symlinks. |
Colin Cross | 1332b00 | 2015-04-07 17:11:30 -0700 | [diff] [blame] | 683 | func (c *config) CpPreserveSymlinksFlags() string { |
Colin Cross | 485e572 | 2015-08-27 13:28:01 -0700 | [diff] [blame] | 684 | switch runtime.GOOS { |
Colin Cross | 3f40fa4 | 2015-01-30 17:27:36 -0800 | [diff] [blame] | 685 | case "darwin": |
| 686 | return "-R" |
| 687 | case "linux": |
| 688 | return "-d" |
| 689 | default: |
| 690 | return "" |
| 691 | } |
| 692 | } |
Colin Cross | 68f5510 | 2015-03-25 14:43:57 -0700 | [diff] [blame] | 693 | |
Colin Cross | 1332b00 | 2015-04-07 17:11:30 -0700 | [diff] [blame] | 694 | func (c *config) Getenv(key string) string { |
Colin Cross | 68f5510 | 2015-03-25 14:43:57 -0700 | [diff] [blame] | 695 | var val string |
| 696 | var exists bool |
Colin Cross | c1e86a3 | 2015-04-15 12:33:28 -0700 | [diff] [blame] | 697 | c.envLock.Lock() |
Colin Cross | c0d58b4 | 2017-02-06 15:40:41 -0800 | [diff] [blame] | 698 | defer c.envLock.Unlock() |
| 699 | if c.envDeps == nil { |
| 700 | c.envDeps = make(map[string]string) |
| 701 | } |
Colin Cross | 68f5510 | 2015-03-25 14:43:57 -0700 | [diff] [blame] | 702 | if val, exists = c.envDeps[key]; !exists { |
Dan Willemsen | e7680ba | 2015-09-11 17:06:19 -0700 | [diff] [blame] | 703 | if c.envFrozen { |
| 704 | panic("Cannot access new environment variables after envdeps are frozen") |
| 705 | } |
Colin Cross | 6ccbc91 | 2017-10-10 23:07:38 -0700 | [diff] [blame] | 706 | val, _ = c.env[key] |
Colin Cross | 68f5510 | 2015-03-25 14:43:57 -0700 | [diff] [blame] | 707 | c.envDeps[key] = val |
| 708 | } |
| 709 | return val |
| 710 | } |
| 711 | |
Colin Cross | 99d7c23 | 2016-11-23 16:52:04 -0800 | [diff] [blame] | 712 | func (c *config) GetenvWithDefault(key string, defaultValue string) string { |
| 713 | ret := c.Getenv(key) |
| 714 | if ret == "" { |
| 715 | return defaultValue |
| 716 | } |
| 717 | return ret |
| 718 | } |
| 719 | |
| 720 | func (c *config) IsEnvTrue(key string) bool { |
| 721 | value := c.Getenv(key) |
| 722 | return value == "1" || value == "y" || value == "yes" || value == "on" || value == "true" |
| 723 | } |
| 724 | |
| 725 | func (c *config) IsEnvFalse(key string) bool { |
| 726 | value := c.Getenv(key) |
| 727 | return value == "0" || value == "n" || value == "no" || value == "off" || value == "false" |
| 728 | } |
| 729 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 730 | // EnvDeps returns the environment variables this build depends on. The first |
| 731 | // call to this function blocks future reads from the environment. |
Colin Cross | 1332b00 | 2015-04-07 17:11:30 -0700 | [diff] [blame] | 732 | func (c *config) EnvDeps() map[string]string { |
Dan Willemsen | e7680ba | 2015-09-11 17:06:19 -0700 | [diff] [blame] | 733 | c.envLock.Lock() |
Colin Cross | c0d58b4 | 2017-02-06 15:40:41 -0800 | [diff] [blame] | 734 | defer c.envLock.Unlock() |
Dan Willemsen | e7680ba | 2015-09-11 17:06:19 -0700 | [diff] [blame] | 735 | c.envFrozen = true |
Colin Cross | 68f5510 | 2015-03-25 14:43:57 -0700 | [diff] [blame] | 736 | return c.envDeps |
| 737 | } |
Colin Cross | 35cec12 | 2015-04-02 14:37:16 -0700 | [diff] [blame] | 738 | |
Jingwen Chen | cda22c9 | 2020-11-23 00:22:30 -0500 | [diff] [blame] | 739 | func (c *config) KatiEnabled() bool { |
| 740 | return c.katiEnabled |
Dan Willemsen | 5ba07e8 | 2015-12-11 13:51:06 -0800 | [diff] [blame] | 741 | } |
| 742 | |
Nan Zhang | 581fd21 | 2018-01-10 16:06:12 -0800 | [diff] [blame] | 743 | func (c *config) BuildId() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 744 | return String(c.productVariables.BuildId) |
Nan Zhang | 581fd21 | 2018-01-10 16:06:12 -0800 | [diff] [blame] | 745 | } |
| 746 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 747 | // BuildNumberFile returns the path to a text file containing metadata |
| 748 | // representing the current build's number. |
| 749 | // |
| 750 | // Rules that want to reference the build number should read from this file |
| 751 | // without depending on it. They will run whenever their other dependencies |
| 752 | // require them to run and get the current build number. This ensures they don't |
| 753 | // rebuild on every incremental build when the build number changes. |
Colin Cross | 2a2e0db | 2020-02-21 16:55:46 -0800 | [diff] [blame] | 754 | func (c *config) BuildNumberFile(ctx PathContext) Path { |
| 755 | return PathForOutput(ctx, String(c.productVariables.BuildNumberFile)) |
Nan Zhang | 581fd21 | 2018-01-10 16:06:12 -0800 | [diff] [blame] | 756 | } |
| 757 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 758 | // DeviceName returns the name of the current device target. |
Colin Cross | 35cec12 | 2015-04-02 14:37:16 -0700 | [diff] [blame] | 759 | // TODO: take an AndroidModuleContext to select the device name for multi-device builds |
Colin Cross | 1332b00 | 2015-04-07 17:11:30 -0700 | [diff] [blame] | 760 | func (c *config) DeviceName() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 761 | return *c.productVariables.DeviceName |
Colin Cross | 35cec12 | 2015-04-02 14:37:16 -0700 | [diff] [blame] | 762 | } |
| 763 | |
Trevor Radcliffe | 90727f4 | 2022-03-21 19:34:02 +0000 | [diff] [blame] | 764 | // DeviceProduct returns the current product target. There could be multiple of |
| 765 | // these per device type. |
| 766 | // |
Chris Parsons | ef615e5 | 2022-08-18 22:04:11 -0400 | [diff] [blame] | 767 | // NOTE: Do not base conditional logic on this value. It may break product inheritance. |
Trevor Radcliffe | 90727f4 | 2022-03-21 19:34:02 +0000 | [diff] [blame] | 768 | func (c *config) DeviceProduct() string { |
| 769 | return *c.productVariables.DeviceProduct |
| 770 | } |
| 771 | |
Cole Faust | b85d1a1 | 2022-11-08 18:14:01 -0800 | [diff] [blame] | 772 | // HasDeviceProduct returns if the build has a product. A build will not |
| 773 | // necessarily have a product when --skip-config is passed to soong, like it is |
| 774 | // in prebuilts/build-tools/build-prebuilts.sh |
| 775 | func (c *config) HasDeviceProduct() bool { |
| 776 | return c.productVariables.DeviceProduct != nil |
| 777 | } |
| 778 | |
Anton Hansson | 53c8844 | 2019-03-18 15:53:16 +0000 | [diff] [blame] | 779 | func (c *config) DeviceResourceOverlays() []string { |
| 780 | return c.productVariables.DeviceResourceOverlays |
| 781 | } |
| 782 | |
| 783 | func (c *config) ProductResourceOverlays() []string { |
| 784 | return c.productVariables.ProductResourceOverlays |
Colin Cross | 30e076a | 2015-04-13 13:58:27 -0700 | [diff] [blame] | 785 | } |
| 786 | |
Colin Cross | bfd347d | 2018-05-09 11:11:35 -0700 | [diff] [blame] | 787 | func (c *config) PlatformVersionName() string { |
| 788 | return String(c.productVariables.Platform_version_name) |
| 789 | } |
| 790 | |
Dan Albert | 4f378d7 | 2020-07-23 17:32:15 -0700 | [diff] [blame] | 791 | func (c *config) PlatformSdkVersion() ApiLevel { |
| 792 | return uncheckedFinalApiLevel(*c.productVariables.Platform_sdk_version) |
Colin Cross | 30e076a | 2015-04-13 13:58:27 -0700 | [diff] [blame] | 793 | } |
| 794 | |
Mu-Le Lee | 5e04753 | 2022-07-27 02:32:03 +0000 | [diff] [blame] | 795 | func (c *config) PlatformSdkFinal() bool { |
| 796 | return Bool(c.productVariables.Platform_sdk_final) |
| 797 | } |
| 798 | |
Colin Cross | d09b0b6 | 2018-04-18 11:06:47 -0700 | [diff] [blame] | 799 | func (c *config) PlatformSdkCodename() string { |
| 800 | return String(c.productVariables.Platform_sdk_codename) |
| 801 | } |
| 802 | |
Anton Hansson | 97d0bae | 2022-02-16 16:15:10 +0000 | [diff] [blame] | 803 | func (c *config) PlatformSdkExtensionVersion() int { |
| 804 | return *c.productVariables.Platform_sdk_extension_version |
| 805 | } |
| 806 | |
| 807 | func (c *config) PlatformBaseSdkExtensionVersion() int { |
| 808 | return *c.productVariables.Platform_base_sdk_extension_version |
| 809 | } |
| 810 | |
Colin Cross | 092c9da | 2019-04-02 22:56:43 -0700 | [diff] [blame] | 811 | func (c *config) PlatformSecurityPatch() string { |
| 812 | return String(c.productVariables.Platform_security_patch) |
| 813 | } |
| 814 | |
| 815 | func (c *config) PlatformPreviewSdkVersion() string { |
| 816 | return String(c.productVariables.Platform_preview_sdk_version) |
| 817 | } |
| 818 | |
| 819 | func (c *config) PlatformMinSupportedTargetSdkVersion() string { |
| 820 | return String(c.productVariables.Platform_min_supported_target_sdk_version) |
| 821 | } |
| 822 | |
| 823 | func (c *config) PlatformBaseOS() string { |
| 824 | return String(c.productVariables.Platform_base_os) |
| 825 | } |
| 826 | |
Inseob Kim | 4f1f3d9 | 2022-04-25 18:23:58 +0900 | [diff] [blame] | 827 | func (c *config) PlatformVersionLastStable() string { |
| 828 | return String(c.productVariables.Platform_version_last_stable) |
| 829 | } |
| 830 | |
Jiyong Park | 3707384 | 2022-06-21 10:13:42 +0900 | [diff] [blame] | 831 | func (c *config) PlatformVersionKnownCodenames() string { |
| 832 | return String(c.productVariables.Platform_version_known_codenames) |
| 833 | } |
| 834 | |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 835 | func (c *config) MinSupportedSdkVersion() ApiLevel { |
Dan Albert | 6bfb6bb | 2022-08-17 20:11:57 +0000 | [diff] [blame] | 836 | return uncheckedFinalApiLevel(21) |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 837 | } |
| 838 | |
| 839 | func (c *config) FinalApiLevels() []ApiLevel { |
| 840 | var levels []ApiLevel |
Dan Albert | 4f378d7 | 2020-07-23 17:32:15 -0700 | [diff] [blame] | 841 | for i := 1; i <= c.PlatformSdkVersion().FinalOrFutureInt(); i++ { |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 842 | levels = append(levels, uncheckedFinalApiLevel(i)) |
| 843 | } |
| 844 | return levels |
| 845 | } |
| 846 | |
| 847 | func (c *config) PreviewApiLevels() []ApiLevel { |
| 848 | var levels []ApiLevel |
| 849 | for i, codename := range c.PlatformVersionActiveCodenames() { |
| 850 | levels = append(levels, ApiLevel{ |
| 851 | value: codename, |
| 852 | number: i, |
| 853 | isPreview: true, |
| 854 | }) |
| 855 | } |
| 856 | return levels |
| 857 | } |
| 858 | |
satayev | cca4ab7 | 2021-11-30 12:33:55 +0000 | [diff] [blame] | 859 | func (c *config) LatestPreviewApiLevel() ApiLevel { |
| 860 | level := NoneApiLevel |
| 861 | for _, l := range c.PreviewApiLevels() { |
| 862 | if l.GreaterThan(level) { |
| 863 | level = l |
| 864 | } |
| 865 | } |
| 866 | return level |
| 867 | } |
| 868 | |
Dan Albert | 1a24627 | 2020-07-06 14:49:35 -0700 | [diff] [blame] | 869 | func (c *config) AllSupportedApiLevels() []ApiLevel { |
| 870 | var levels []ApiLevel |
| 871 | levels = append(levels, c.FinalApiLevels()...) |
| 872 | return append(levels, c.PreviewApiLevels()...) |
Dan Albert | f5415d7 | 2017-08-17 16:19:59 -0700 | [diff] [blame] | 873 | } |
| 874 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 875 | // DefaultAppTargetSdk returns the API level that platform apps are targeting. |
| 876 | // This converts a codename to the exact ApiLevel it represents. |
Dan Albert | 4f378d7 | 2020-07-23 17:32:15 -0700 | [diff] [blame] | 877 | func (c *config) DefaultAppTargetSdk(ctx EarlyModuleContext) ApiLevel { |
Alix | fb7f7b9 | 2023-03-02 19:35:02 +0000 | [diff] [blame^] | 878 | // This logic is replicated in starlark, if changing logic here update starlark code too |
| 879 | // https://cs.android.com/android/platform/superproject/+/master:build/bazel/rules/common/api.bzl;l=72;drc=231c7e8c8038fd478a79eb68aa5b9f5c64e0e061 |
Colin Cross | d09b0b6 | 2018-04-18 11:06:47 -0700 | [diff] [blame] | 880 | if Bool(c.productVariables.Platform_sdk_final) { |
| 881 | return c.PlatformSdkVersion() |
Colin Cross | d09b0b6 | 2018-04-18 11:06:47 -0700 | [diff] [blame] | 882 | } |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 883 | codename := c.PlatformSdkCodename() |
| 884 | if codename == "" { |
| 885 | return NoneApiLevel |
| 886 | } |
| 887 | if codename == "REL" { |
| 888 | panic("Platform_sdk_codename should not be REL when Platform_sdk_final is true") |
| 889 | } |
| 890 | return ApiLevelOrPanic(ctx, codename) |
Colin Cross | d09b0b6 | 2018-04-18 11:06:47 -0700 | [diff] [blame] | 891 | } |
| 892 | |
Colin Cross | 3bc7ffa | 2017-11-22 16:19:37 -0800 | [diff] [blame] | 893 | func (c *config) AppsDefaultVersionName() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 894 | return String(c.productVariables.AppsDefaultVersionName) |
Colin Cross | 3bc7ffa | 2017-11-22 16:19:37 -0800 | [diff] [blame] | 895 | } |
| 896 | |
Dan Albert | 31384de | 2017-07-28 12:39:46 -0700 | [diff] [blame] | 897 | // Codenames that are active in the current lunch target. |
| 898 | func (c *config) PlatformVersionActiveCodenames() []string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 899 | return c.productVariables.Platform_version_active_codenames |
Dan Albert | 31384de | 2017-07-28 12:39:46 -0700 | [diff] [blame] | 900 | } |
| 901 | |
Colin Cross | face4e4 | 2017-10-30 17:32:15 -0700 | [diff] [blame] | 902 | func (c *config) ProductAAPTConfig() []string { |
Colin Cross | a74ca04 | 2019-01-31 14:31:51 -0800 | [diff] [blame] | 903 | return c.productVariables.AAPTConfig |
Colin Cross | 30e076a | 2015-04-13 13:58:27 -0700 | [diff] [blame] | 904 | } |
| 905 | |
Colin Cross | face4e4 | 2017-10-30 17:32:15 -0700 | [diff] [blame] | 906 | func (c *config) ProductAAPTPreferredConfig() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 907 | return String(c.productVariables.AAPTPreferredConfig) |
Colin Cross | 30e076a | 2015-04-13 13:58:27 -0700 | [diff] [blame] | 908 | } |
| 909 | |
Colin Cross | face4e4 | 2017-10-30 17:32:15 -0700 | [diff] [blame] | 910 | func (c *config) ProductAAPTCharacteristics() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 911 | return String(c.productVariables.AAPTCharacteristics) |
Colin Cross | face4e4 | 2017-10-30 17:32:15 -0700 | [diff] [blame] | 912 | } |
| 913 | |
| 914 | func (c *config) ProductAAPTPrebuiltDPI() []string { |
Colin Cross | a74ca04 | 2019-01-31 14:31:51 -0800 | [diff] [blame] | 915 | return c.productVariables.AAPTPrebuiltDPI |
Colin Cross | 30e076a | 2015-04-13 13:58:27 -0700 | [diff] [blame] | 916 | } |
| 917 | |
Dan Willemsen | 34cc69e | 2015-09-23 15:26:20 -0700 | [diff] [blame] | 918 | func (c *config) DefaultAppCertificateDir(ctx PathContext) SourcePath { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 919 | defaultCert := String(c.productVariables.DefaultAppCertificate) |
Colin Cross | 61ae0b7 | 2017-12-01 17:16:02 -0800 | [diff] [blame] | 920 | if defaultCert != "" { |
| 921 | return PathForSource(ctx, filepath.Dir(defaultCert)) |
Colin Cross | 61ae0b7 | 2017-12-01 17:16:02 -0800 | [diff] [blame] | 922 | } |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 923 | return PathForSource(ctx, "build/make/target/product/security") |
Colin Cross | 30e076a | 2015-04-13 13:58:27 -0700 | [diff] [blame] | 924 | } |
| 925 | |
Colin Cross | e1731a5 | 2017-12-14 11:22:55 -0800 | [diff] [blame] | 926 | func (c *config) DefaultAppCertificate(ctx PathContext) (pem, key SourcePath) { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 927 | defaultCert := String(c.productVariables.DefaultAppCertificate) |
Colin Cross | 61ae0b7 | 2017-12-01 17:16:02 -0800 | [diff] [blame] | 928 | if defaultCert != "" { |
Colin Cross | e1731a5 | 2017-12-14 11:22:55 -0800 | [diff] [blame] | 929 | return PathForSource(ctx, defaultCert+".x509.pem"), PathForSource(ctx, defaultCert+".pk8") |
Colin Cross | 61ae0b7 | 2017-12-01 17:16:02 -0800 | [diff] [blame] | 930 | } |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 931 | defaultDir := c.DefaultAppCertificateDir(ctx) |
| 932 | return defaultDir.Join(ctx, "testkey.x509.pem"), defaultDir.Join(ctx, "testkey.pk8") |
Colin Cross | 30e076a | 2015-04-13 13:58:27 -0700 | [diff] [blame] | 933 | } |
Colin Cross | 6ff5138 | 2015-12-17 16:39:19 -0800 | [diff] [blame] | 934 | |
Jiyong Park | 9335a26 | 2018-12-24 11:31:58 +0900 | [diff] [blame] | 935 | func (c *config) ApexKeyDir(ctx ModuleContext) SourcePath { |
| 936 | // TODO(b/121224311): define another variable such as TARGET_APEX_KEY_OVERRIDE |
| 937 | defaultCert := String(c.productVariables.DefaultAppCertificate) |
Dan Willemsen | 412160e | 2019-04-09 21:36:26 -0700 | [diff] [blame] | 938 | if defaultCert == "" || filepath.Dir(defaultCert) == "build/make/target/product/security" { |
Jiyong Park | 9335a26 | 2018-12-24 11:31:58 +0900 | [diff] [blame] | 939 | // When defaultCert is unset or is set to the testkeys path, use the APEX keys |
| 940 | // that is under the module dir |
Colin Cross | 07e5161 | 2019-03-05 12:46:40 -0800 | [diff] [blame] | 941 | return pathForModuleSrc(ctx) |
Jiyong Park | 9335a26 | 2018-12-24 11:31:58 +0900 | [diff] [blame] | 942 | } |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 943 | // If not, APEX keys are under the specified directory |
| 944 | return PathForSource(ctx, filepath.Dir(defaultCert)) |
Jiyong Park | 9335a26 | 2018-12-24 11:31:58 +0900 | [diff] [blame] | 945 | } |
| 946 | |
Inseob Kim | 80fa798 | 2022-08-12 21:36:25 +0900 | [diff] [blame] | 947 | // Certificate for the NetworkStack sepolicy context |
| 948 | func (c *config) MainlineSepolicyDevCertificatesDir(ctx ModuleContext) SourcePath { |
| 949 | cert := String(c.productVariables.MainlineSepolicyDevCertificates) |
| 950 | if cert != "" { |
| 951 | return PathForSource(ctx, cert) |
| 952 | } |
| 953 | return c.DefaultAppCertificateDir(ctx) |
| 954 | } |
| 955 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 956 | // AllowMissingDependencies configures Blueprint/Soong to not fail when modules |
| 957 | // are configured to depend on non-existent modules. Note that this does not |
| 958 | // affect missing input dependencies at the Ninja level. |
Colin Cross | 6ff5138 | 2015-12-17 16:39:19 -0800 | [diff] [blame] | 959 | func (c *config) AllowMissingDependencies() bool { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 960 | return Bool(c.productVariables.Allow_missing_dependencies) |
Colin Cross | 6ff5138 | 2015-12-17 16:39:19 -0800 | [diff] [blame] | 961 | } |
Dan Willemsen | 322acaf | 2016-01-12 23:07:05 -0800 | [diff] [blame] | 962 | |
Jeongik Cha | 816a23a | 2020-07-08 01:09:23 +0900 | [diff] [blame] | 963 | // Returns true if a full platform source tree cannot be assumed. |
Colin Cross | fc3674a | 2017-09-18 17:41:52 -0700 | [diff] [blame] | 964 | func (c *config) UnbundledBuild() bool { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 965 | return Bool(c.productVariables.Unbundled_build) |
Colin Cross | fc3674a | 2017-09-18 17:41:52 -0700 | [diff] [blame] | 966 | } |
| 967 | |
Martin Stjernholm | fd9eb4b | 2020-06-17 01:13:15 +0100 | [diff] [blame] | 968 | // Returns true if building apps that aren't bundled with the platform. |
| 969 | // UnbundledBuild() is always true when this is true. |
| 970 | func (c *config) UnbundledBuildApps() bool { |
Cole Faust | 701ca25 | 2021-11-23 19:02:08 -0800 | [diff] [blame] | 971 | return len(c.productVariables.Unbundled_build_apps) > 0 |
Martin Stjernholm | fd9eb4b | 2020-06-17 01:13:15 +0100 | [diff] [blame] | 972 | } |
| 973 | |
Jeongik Cha | 4b073cd | 2021-06-08 11:35:00 +0900 | [diff] [blame] | 974 | // Returns true if building image that aren't bundled with the platform. |
| 975 | // UnbundledBuild() is always true when this is true. |
| 976 | func (c *config) UnbundledBuildImage() bool { |
| 977 | return Bool(c.productVariables.Unbundled_build_image) |
| 978 | } |
| 979 | |
Jeongik Cha | 816a23a | 2020-07-08 01:09:23 +0900 | [diff] [blame] | 980 | // Returns true if building modules against prebuilt SDKs. |
| 981 | func (c *config) AlwaysUsePrebuiltSdks() bool { |
| 982 | return Bool(c.productVariables.Always_use_prebuilt_sdks) |
Colin Cross | 1f367bf | 2018-12-18 22:46:24 -0800 | [diff] [blame] | 983 | } |
| 984 | |
Colin Cross | 126a25c | 2017-10-31 13:55:34 -0700 | [diff] [blame] | 985 | func (c *config) MinimizeJavaDebugInfo() bool { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 986 | return Bool(c.productVariables.MinimizeJavaDebugInfo) && !Bool(c.productVariables.Eng) |
Colin Cross | 126a25c | 2017-10-31 13:55:34 -0700 | [diff] [blame] | 987 | } |
| 988 | |
Colin Cross | ed064c0 | 2018-09-05 16:28:13 -0700 | [diff] [blame] | 989 | func (c *config) Debuggable() bool { |
| 990 | return Bool(c.productVariables.Debuggable) |
| 991 | } |
| 992 | |
Jaewoong Jung | 1d6eb68 | 2018-11-29 15:08:44 -0800 | [diff] [blame] | 993 | func (c *config) Eng() bool { |
| 994 | return Bool(c.productVariables.Eng) |
| 995 | } |
| 996 | |
Colin Cross | c53c37f | 2021-12-08 15:42:22 -0800 | [diff] [blame] | 997 | // DevicePrimaryArchType returns the ArchType for the first configured device architecture, or |
| 998 | // Common if there are no device architectures. |
Jiyong Park | 8d52f86 | 2018-07-07 18:02:07 +0900 | [diff] [blame] | 999 | func (c *config) DevicePrimaryArchType() ArchType { |
Colin Cross | c53c37f | 2021-12-08 15:42:22 -0800 | [diff] [blame] | 1000 | if androidTargets := c.Targets[Android]; len(androidTargets) > 0 { |
| 1001 | return androidTargets[0].Arch.ArchType |
| 1002 | } |
| 1003 | return Common |
Jiyong Park | 8d52f86 | 2018-07-07 18:02:07 +0900 | [diff] [blame] | 1004 | } |
| 1005 | |
Colin Cross | 16b2349 | 2016-01-06 14:41:07 -0800 | [diff] [blame] | 1006 | func (c *config) SanitizeHost() []string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1007 | return append([]string(nil), c.productVariables.SanitizeHost...) |
Colin Cross | 16b2349 | 2016-01-06 14:41:07 -0800 | [diff] [blame] | 1008 | } |
| 1009 | |
| 1010 | func (c *config) SanitizeDevice() []string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1011 | return append([]string(nil), c.productVariables.SanitizeDevice...) |
Colin Cross | 23ae82a | 2016-11-02 14:34:39 -0700 | [diff] [blame] | 1012 | } |
| 1013 | |
Ivan Lozano | 0c3a1ef | 2017-06-28 09:10:48 -0700 | [diff] [blame] | 1014 | func (c *config) SanitizeDeviceDiag() []string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1015 | return append([]string(nil), c.productVariables.SanitizeDeviceDiag...) |
Ivan Lozano | 0c3a1ef | 2017-06-28 09:10:48 -0700 | [diff] [blame] | 1016 | } |
| 1017 | |
Colin Cross | 23ae82a | 2016-11-02 14:34:39 -0700 | [diff] [blame] | 1018 | func (c *config) SanitizeDeviceArch() []string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1019 | return append([]string(nil), c.productVariables.SanitizeDeviceArch...) |
Colin Cross | 16b2349 | 2016-01-06 14:41:07 -0800 | [diff] [blame] | 1020 | } |
Colin Cross | a1ad8d1 | 2016-06-01 17:09:44 -0700 | [diff] [blame] | 1021 | |
Vishwath Mohan | 1b017a7 | 2017-01-19 13:54:55 -0800 | [diff] [blame] | 1022 | func (c *config) EnableCFI() bool { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1023 | if c.productVariables.EnableCFI == nil { |
Vishwath Mohan | c32c3eb | 2017-01-24 14:20:54 -0800 | [diff] [blame] | 1024 | return true |
Vishwath Mohan | c32c3eb | 2017-01-24 14:20:54 -0800 | [diff] [blame] | 1025 | } |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 1026 | return *c.productVariables.EnableCFI |
Vishwath Mohan | 1b017a7 | 2017-01-19 13:54:55 -0800 | [diff] [blame] | 1027 | } |
| 1028 | |
Kostya Kortchinsky | d5275c8 | 2019-02-01 08:42:56 -0800 | [diff] [blame] | 1029 | func (c *config) DisableScudo() bool { |
| 1030 | return Bool(c.productVariables.DisableScudo) |
| 1031 | } |
| 1032 | |
Colin Cross | a1ad8d1 | 2016-06-01 17:09:44 -0700 | [diff] [blame] | 1033 | func (c *config) Android64() bool { |
Dan Willemsen | 0ef639b | 2018-10-10 17:02:29 -0700 | [diff] [blame] | 1034 | for _, t := range c.Targets[Android] { |
Colin Cross | a1ad8d1 | 2016-06-01 17:09:44 -0700 | [diff] [blame] | 1035 | if t.Arch.ArchType.Multilib == "lib64" { |
| 1036 | return true |
| 1037 | } |
| 1038 | } |
| 1039 | |
| 1040 | return false |
| 1041 | } |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 1042 | |
Colin Cross | 9d45bb7 | 2016-08-29 16:14:13 -0700 | [diff] [blame] | 1043 | func (c *config) UseGoma() bool { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1044 | return Bool(c.productVariables.UseGoma) |
Colin Cross | 9d45bb7 | 2016-08-29 16:14:13 -0700 | [diff] [blame] | 1045 | } |
| 1046 | |
Ramy Medhat | bbf2567 | 2019-07-17 12:30:04 +0000 | [diff] [blame] | 1047 | func (c *config) UseRBE() bool { |
| 1048 | return Bool(c.productVariables.UseRBE) |
| 1049 | } |
| 1050 | |
Ramy Medhat | 8ea054a | 2020-01-27 14:19:44 -0500 | [diff] [blame] | 1051 | func (c *config) UseRBEJAVAC() bool { |
| 1052 | return Bool(c.productVariables.UseRBEJAVAC) |
| 1053 | } |
| 1054 | |
| 1055 | func (c *config) UseRBER8() bool { |
| 1056 | return Bool(c.productVariables.UseRBER8) |
| 1057 | } |
| 1058 | |
| 1059 | func (c *config) UseRBED8() bool { |
| 1060 | return Bool(c.productVariables.UseRBED8) |
| 1061 | } |
| 1062 | |
Colin Cross | 8b8bec3 | 2019-11-15 13:18:43 -0800 | [diff] [blame] | 1063 | func (c *config) UseRemoteBuild() bool { |
| 1064 | return c.UseGoma() || c.UseRBE() |
| 1065 | } |
| 1066 | |
Colin Cross | 6654810 | 2018-06-19 22:47:35 -0700 | [diff] [blame] | 1067 | func (c *config) RunErrorProne() bool { |
| 1068 | return c.IsEnvTrue("RUN_ERROR_PRONE") |
| 1069 | } |
| 1070 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 1071 | // XrefCorpusName returns the Kythe cross-reference corpus name. |
Sasha Smundak | 2a4549e | 2018-11-05 16:49:08 -0800 | [diff] [blame] | 1072 | func (c *config) XrefCorpusName() string { |
| 1073 | return c.Getenv("XREF_CORPUS") |
| 1074 | } |
| 1075 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 1076 | // XrefCuEncoding returns the compilation unit encoding to use for Kythe code |
| 1077 | // xrefs. Can be 'json' (default), 'proto' or 'all'. |
Sasha Smundak | 6c2d4f9 | 2020-01-09 17:34:23 -0800 | [diff] [blame] | 1078 | func (c *config) XrefCuEncoding() string { |
| 1079 | if enc := c.Getenv("KYTHE_KZIP_ENCODING"); enc != "" { |
| 1080 | return enc |
| 1081 | } |
| 1082 | return "json" |
| 1083 | } |
| 1084 | |
Sasha Smundak | b0addaf | 2021-02-16 10:39:40 -0800 | [diff] [blame] | 1085 | // XrefCuJavaSourceMax returns the maximum number of the Java source files |
| 1086 | // in a single compilation unit |
| 1087 | const xrefJavaSourceFileMaxDefault = "1000" |
| 1088 | |
| 1089 | func (c Config) XrefCuJavaSourceMax() string { |
| 1090 | v := c.Getenv("KYTHE_JAVA_SOURCE_BATCH_SIZE") |
| 1091 | if v == "" { |
| 1092 | return xrefJavaSourceFileMaxDefault |
| 1093 | } |
| 1094 | if _, err := strconv.ParseUint(v, 0, 0); err != nil { |
| 1095 | fmt.Fprintf(os.Stderr, |
| 1096 | "bad KYTHE_JAVA_SOURCE_BATCH_SIZE value: %s, will use %s", |
| 1097 | err, xrefJavaSourceFileMaxDefault) |
| 1098 | return xrefJavaSourceFileMaxDefault |
| 1099 | } |
| 1100 | return v |
| 1101 | |
| 1102 | } |
| 1103 | |
Sasha Smundak | 2a4549e | 2018-11-05 16:49:08 -0800 | [diff] [blame] | 1104 | func (c *config) EmitXrefRules() bool { |
| 1105 | return c.XrefCorpusName() != "" |
| 1106 | } |
| 1107 | |
Dan Willemsen | a03cf6d | 2016-09-26 15:45:04 -0700 | [diff] [blame] | 1108 | func (c *config) ClangTidy() bool { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1109 | return Bool(c.productVariables.ClangTidy) |
Dan Willemsen | a03cf6d | 2016-09-26 15:45:04 -0700 | [diff] [blame] | 1110 | } |
| 1111 | |
| 1112 | func (c *config) TidyChecks() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1113 | if c.productVariables.TidyChecks == nil { |
Dan Willemsen | a03cf6d | 2016-09-26 15:45:04 -0700 | [diff] [blame] | 1114 | return "" |
| 1115 | } |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1116 | return *c.productVariables.TidyChecks |
Dan Willemsen | a03cf6d | 2016-09-26 15:45:04 -0700 | [diff] [blame] | 1117 | } |
| 1118 | |
Colin Cross | 0f4e0d6 | 2016-07-27 10:56:55 -0700 | [diff] [blame] | 1119 | func (c *config) LibartImgHostBaseAddress() string { |
| 1120 | return "0x60000000" |
| 1121 | } |
| 1122 | |
| 1123 | func (c *config) LibartImgDeviceBaseAddress() string { |
Elliott Hughes | da3a071 | 2020-03-06 16:55:28 -0800 | [diff] [blame] | 1124 | return "0x70000000" |
Colin Cross | 0f4e0d6 | 2016-07-27 10:56:55 -0700 | [diff] [blame] | 1125 | } |
| 1126 | |
Hiroshi Yamauchi | e2a1063 | 2016-12-19 13:44:41 -0800 | [diff] [blame] | 1127 | func (c *config) ArtUseReadBarrier() bool { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1128 | return Bool(c.productVariables.ArtUseReadBarrier) |
Hiroshi Yamauchi | e2a1063 | 2016-12-19 13:44:41 -0800 | [diff] [blame] | 1129 | } |
| 1130 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 1131 | // Enforce Runtime Resource Overlays for a module. RROs supersede static RROs, |
| 1132 | // but some modules still depend on it. |
| 1133 | // |
| 1134 | // More info: https://source.android.com/devices/architecture/rros |
Dan Willemsen | 3fb1fae | 2018-03-12 15:30:26 -0700 | [diff] [blame] | 1135 | func (c *config) EnforceRROForModule(name string) bool { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1136 | enforceList := c.productVariables.EnforceRROTargets |
Jeongik Cha | cee5ba9 | 2021-02-19 12:11:51 +0900 | [diff] [blame] | 1137 | |
Roland Levillain | f6cc261 | 2020-07-09 16:58:14 +0100 | [diff] [blame] | 1138 | if len(enforceList) > 0 { |
Yo Chiang | 4ebd06a | 2019-10-01 13:13:41 +0800 | [diff] [blame] | 1139 | if InList("*", enforceList) { |
Dan Willemsen | 3fb1fae | 2018-03-12 15:30:26 -0700 | [diff] [blame] | 1140 | return true |
| 1141 | } |
Colin Cross | a74ca04 | 2019-01-31 14:31:51 -0800 | [diff] [blame] | 1142 | return InList(name, enforceList) |
Dan Willemsen | 3fb1fae | 2018-03-12 15:30:26 -0700 | [diff] [blame] | 1143 | } |
| 1144 | return false |
| 1145 | } |
Dan Willemsen | 3fb1fae | 2018-03-12 15:30:26 -0700 | [diff] [blame] | 1146 | func (c *config) EnforceRROExcludedOverlay(path string) bool { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1147 | excluded := c.productVariables.EnforceRROExcludedOverlays |
Roland Levillain | f6cc261 | 2020-07-09 16:58:14 +0100 | [diff] [blame] | 1148 | if len(excluded) > 0 { |
Jaewoong Jung | 3aff578 | 2020-02-11 07:54:35 -0800 | [diff] [blame] | 1149 | return HasAnyPrefix(path, excluded) |
Dan Willemsen | 3fb1fae | 2018-03-12 15:30:26 -0700 | [diff] [blame] | 1150 | } |
| 1151 | return false |
| 1152 | } |
| 1153 | |
| 1154 | func (c *config) ExportedNamespaces() []string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1155 | return append([]string(nil), c.productVariables.NamespacesToExport...) |
Dan Willemsen | 3fb1fae | 2018-03-12 15:30:26 -0700 | [diff] [blame] | 1156 | } |
| 1157 | |
Spandan Das | c576383 | 2022-11-08 18:42:16 +0000 | [diff] [blame] | 1158 | func (c *config) IncludeTags() []string { |
| 1159 | return c.productVariables.IncludeTags |
| 1160 | } |
| 1161 | |
Dan Willemsen | 3fb1fae | 2018-03-12 15:30:26 -0700 | [diff] [blame] | 1162 | func (c *config) HostStaticBinaries() bool { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1163 | return Bool(c.productVariables.HostStaticBinaries) |
Dan Willemsen | 3fb1fae | 2018-03-12 15:30:26 -0700 | [diff] [blame] | 1164 | } |
| 1165 | |
Colin Cross | 5a0dcd5 | 2018-10-05 14:20:06 -0700 | [diff] [blame] | 1166 | func (c *config) UncompressPrivAppDex() bool { |
| 1167 | return Bool(c.productVariables.UncompressPrivAppDex) |
| 1168 | } |
| 1169 | |
| 1170 | func (c *config) ModulesLoadedByPrivilegedModules() []string { |
| 1171 | return c.productVariables.ModulesLoadedByPrivilegedModules |
| 1172 | } |
| 1173 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 1174 | // DexpreoptGlobalConfigPath returns the path to the dexpreopt.config file in |
| 1175 | // the output directory, if it was created during the product configuration |
| 1176 | // phase by Kati. |
Jingwen Chen | ebb0b57 | 2020-11-02 00:24:57 -0500 | [diff] [blame] | 1177 | func (c *config) DexpreoptGlobalConfigPath(ctx PathContext) OptionalPath { |
Colin Cross | 988414c | 2020-01-11 01:11:46 +0000 | [diff] [blame] | 1178 | if c.productVariables.DexpreoptGlobalConfig == nil { |
Jingwen Chen | ebb0b57 | 2020-11-02 00:24:57 -0500 | [diff] [blame] | 1179 | return OptionalPathForPath(nil) |
| 1180 | } |
| 1181 | return OptionalPathForPath( |
| 1182 | pathForBuildToolDep(ctx, *c.productVariables.DexpreoptGlobalConfig)) |
| 1183 | } |
| 1184 | |
Jingwen Chen | c711fec | 2020-11-22 23:52:50 -0500 | [diff] [blame] | 1185 | // DexpreoptGlobalConfig returns the raw byte contents of the dexpreopt global |
| 1186 | // configuration. Since the configuration file was created by Kati during |
| 1187 | // product configuration (externally of soong_build), it's not tracked, so we |
| 1188 | // also manually add a Ninja file dependency on the configuration file to the |
| 1189 | // rule that creates the main build.ninja file. This ensures that build.ninja is |
| 1190 | // regenerated correctly if dexpreopt.config changes. |
Jingwen Chen | ebb0b57 | 2020-11-02 00:24:57 -0500 | [diff] [blame] | 1191 | func (c *config) DexpreoptGlobalConfig(ctx PathContext) ([]byte, error) { |
| 1192 | path := c.DexpreoptGlobalConfigPath(ctx) |
| 1193 | if !path.Valid() { |
Colin Cross | 988414c | 2020-01-11 01:11:46 +0000 | [diff] [blame] | 1194 | return nil, nil |
| 1195 | } |
Jingwen Chen | ebb0b57 | 2020-11-02 00:24:57 -0500 | [diff] [blame] | 1196 | ctx.AddNinjaFileDeps(path.String()) |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 1197 | return os.ReadFile(absolutePath(path.String())) |
Colin Cross | 43f08db | 2018-11-12 10:13:39 -0800 | [diff] [blame] | 1198 | } |
| 1199 | |
Inseob Kim | 7b85eeb | 2021-03-23 20:52:24 +0900 | [diff] [blame] | 1200 | func (c *deviceConfig) WithDexpreopt() bool { |
| 1201 | return c.config.productVariables.WithDexpreopt |
| 1202 | } |
| 1203 | |
Colin Cross | 662d614 | 2022-11-03 20:38:01 -0700 | [diff] [blame] | 1204 | func (c *config) FrameworksBaseDirExists(ctx PathGlobContext) bool { |
Colin Cross | 5a756a6 | 2021-03-16 16:34:46 -0700 | [diff] [blame] | 1205 | return ExistentPathForSource(ctx, "frameworks", "base", "Android.bp").Valid() |
David Brazdil | 91b4e3e | 2019-01-23 21:04:05 +0000 | [diff] [blame] | 1206 | } |
| 1207 | |
Inseob Kim | ae55303 | 2019-05-14 18:52:49 +0900 | [diff] [blame] | 1208 | func (c *config) VndkSnapshotBuildArtifacts() bool { |
| 1209 | return Bool(c.productVariables.VndkSnapshotBuildArtifacts) |
| 1210 | } |
| 1211 | |
Colin Cross | 3b19f5d | 2019-09-17 14:45:31 -0700 | [diff] [blame] | 1212 | func (c *config) HasMultilibConflict(arch ArchType) bool { |
| 1213 | return c.multilibConflicts[arch] |
| 1214 | } |
| 1215 | |
Sasha Smundak | af5ca92 | 2022-12-12 21:23:34 -0800 | [diff] [blame] | 1216 | func (c *config) PrebuiltHiddenApiDir(_ PathContext) string { |
Bill Peckham | bae4749 | 2021-01-08 09:34:44 -0800 | [diff] [blame] | 1217 | return String(c.productVariables.PrebuiltHiddenApiDir) |
| 1218 | } |
| 1219 | |
MarkDacek | d06db5d | 2022-11-29 00:47:59 +0000 | [diff] [blame] | 1220 | func (c *config) BazelModulesForceEnabledByFlag() map[string]struct{} { |
| 1221 | return c.bazelForceEnabledModules |
| 1222 | } |
| 1223 | |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 1224 | func (c *deviceConfig) Arches() []Arch { |
| 1225 | var arches []Arch |
Dan Willemsen | 0ef639b | 2018-10-10 17:02:29 -0700 | [diff] [blame] | 1226 | for _, target := range c.config.Targets[Android] { |
Colin Cross | 9272ade | 2016-08-17 15:24:12 -0700 | [diff] [blame] | 1227 | arches = append(arches, target.Arch) |
| 1228 | } |
| 1229 | return arches |
| 1230 | } |
Dan Willemsen | d2ede87 | 2016-11-18 14:54:24 -0800 | [diff] [blame] | 1231 | |
Jayant Chowdhary | 34ce67d | 2018-03-08 11:00:50 -0800 | [diff] [blame] | 1232 | func (c *deviceConfig) BinderBitness() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1233 | is32BitBinder := c.config.productVariables.Binder32bit |
Jayant Chowdhary | 34ce67d | 2018-03-08 11:00:50 -0800 | [diff] [blame] | 1234 | if is32BitBinder != nil && *is32BitBinder { |
| 1235 | return "32" |
| 1236 | } |
| 1237 | return "64" |
| 1238 | } |
| 1239 | |
Dan Willemsen | 4353bc4 | 2016-12-05 17:16:02 -0800 | [diff] [blame] | 1240 | func (c *deviceConfig) VendorPath() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1241 | if c.config.productVariables.VendorPath != nil { |
| 1242 | return *c.config.productVariables.VendorPath |
Dan Willemsen | 4353bc4 | 2016-12-05 17:16:02 -0800 | [diff] [blame] | 1243 | } |
| 1244 | return "vendor" |
| 1245 | } |
| 1246 | |
Justin Yun | 7154928 | 2017-11-17 12:10:28 +0900 | [diff] [blame] | 1247 | func (c *deviceConfig) VndkVersion() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1248 | return String(c.config.productVariables.DeviceVndkVersion) |
Justin Yun | 7154928 | 2017-11-17 12:10:28 +0900 | [diff] [blame] | 1249 | } |
| 1250 | |
Jose Galmes | 6f843bc | 2020-12-11 13:36:29 -0800 | [diff] [blame] | 1251 | func (c *deviceConfig) RecoverySnapshotVersion() string { |
| 1252 | return String(c.config.productVariables.RecoverySnapshotVersion) |
| 1253 | } |
| 1254 | |
Jeongik Cha | 219141c | 2020-08-06 23:00:37 +0900 | [diff] [blame] | 1255 | func (c *deviceConfig) CurrentApiLevelForVendorModules() string { |
| 1256 | return StringDefault(c.config.productVariables.DeviceCurrentApiLevelForVendorModules, "current") |
| 1257 | } |
| 1258 | |
Justin Yun | 8fe1212 | 2017-12-07 17:18:15 +0900 | [diff] [blame] | 1259 | func (c *deviceConfig) PlatformVndkVersion() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1260 | return String(c.config.productVariables.Platform_vndk_version) |
Justin Yun | 8fe1212 | 2017-12-07 17:18:15 +0900 | [diff] [blame] | 1261 | } |
| 1262 | |
Justin Yun | 5f7f7e8 | 2019-11-18 19:52:14 +0900 | [diff] [blame] | 1263 | func (c *deviceConfig) ProductVndkVersion() string { |
| 1264 | return String(c.config.productVariables.ProductVndkVersion) |
| 1265 | } |
| 1266 | |
Justin Yun | 7154928 | 2017-11-17 12:10:28 +0900 | [diff] [blame] | 1267 | func (c *deviceConfig) ExtraVndkVersions() []string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1268 | return c.config.productVariables.ExtraVndkVersions |
Dan Willemsen | d2ede87 | 2016-11-18 14:54:24 -0800 | [diff] [blame] | 1269 | } |
Jack He | 8cc7143 | 2016-12-08 15:45:07 -0800 | [diff] [blame] | 1270 | |
Vic Yang | efd249e | 2018-11-12 20:19:56 -0800 | [diff] [blame] | 1271 | func (c *deviceConfig) VndkUseCoreVariant() bool { |
| 1272 | return Bool(c.config.productVariables.VndkUseCoreVariant) |
| 1273 | } |
| 1274 | |
Jiyong Park | 1a5d7b1 | 2018-01-15 15:05:10 +0900 | [diff] [blame] | 1275 | func (c *deviceConfig) SystemSdkVersions() []string { |
Colin Cross | a74ca04 | 2019-01-31 14:31:51 -0800 | [diff] [blame] | 1276 | return c.config.productVariables.DeviceSystemSdkVersions |
Jiyong Park | 1a5d7b1 | 2018-01-15 15:05:10 +0900 | [diff] [blame] | 1277 | } |
| 1278 | |
| 1279 | func (c *deviceConfig) PlatformSystemSdkVersions() []string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1280 | return c.config.productVariables.Platform_systemsdk_versions |
Jiyong Park | 1a5d7b1 | 2018-01-15 15:05:10 +0900 | [diff] [blame] | 1281 | } |
| 1282 | |
Jiyong Park | 2db7692 | 2017-11-08 16:03:48 +0900 | [diff] [blame] | 1283 | func (c *deviceConfig) OdmPath() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1284 | if c.config.productVariables.OdmPath != nil { |
| 1285 | return *c.config.productVariables.OdmPath |
Jiyong Park | 2db7692 | 2017-11-08 16:03:48 +0900 | [diff] [blame] | 1286 | } |
| 1287 | return "odm" |
| 1288 | } |
| 1289 | |
Jaekyun Seok | 5cfbfbb | 2018-01-10 19:00:15 +0900 | [diff] [blame] | 1290 | func (c *deviceConfig) ProductPath() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1291 | if c.config.productVariables.ProductPath != nil { |
| 1292 | return *c.config.productVariables.ProductPath |
Jiyong Park | 2db7692 | 2017-11-08 16:03:48 +0900 | [diff] [blame] | 1293 | } |
Jaekyun Seok | 5cfbfbb | 2018-01-10 19:00:15 +0900 | [diff] [blame] | 1294 | return "product" |
Jiyong Park | 2db7692 | 2017-11-08 16:03:48 +0900 | [diff] [blame] | 1295 | } |
| 1296 | |
Justin Yun | d5f6c82 | 2019-06-25 16:47:17 +0900 | [diff] [blame] | 1297 | func (c *deviceConfig) SystemExtPath() string { |
| 1298 | if c.config.productVariables.SystemExtPath != nil { |
| 1299 | return *c.config.productVariables.SystemExtPath |
Dario Freni | fd05a74 | 2018-05-29 13:28:54 +0100 | [diff] [blame] | 1300 | } |
Justin Yun | d5f6c82 | 2019-06-25 16:47:17 +0900 | [diff] [blame] | 1301 | return "system_ext" |
Dario Freni | fd05a74 | 2018-05-29 13:28:54 +0100 | [diff] [blame] | 1302 | } |
| 1303 | |
Jack He | 8cc7143 | 2016-12-08 15:45:07 -0800 | [diff] [blame] | 1304 | func (c *deviceConfig) BtConfigIncludeDir() string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1305 | return String(c.config.productVariables.BtConfigIncludeDir) |
Jack He | 8cc7143 | 2016-12-08 15:45:07 -0800 | [diff] [blame] | 1306 | } |
Dan Willemsen | 581341d | 2017-02-09 16:16:31 -0800 | [diff] [blame] | 1307 | |
Jiyong Park | d773eb3 | 2017-07-03 13:18:12 +0900 | [diff] [blame] | 1308 | func (c *deviceConfig) DeviceKernelHeaderDirs() []string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1309 | return c.config.productVariables.DeviceKernelHeaders |
Jiyong Park | d773eb3 | 2017-07-03 13:18:12 +0900 | [diff] [blame] | 1310 | } |
| 1311 | |
Roland Levillain | ada1270 | 2020-06-09 13:07:36 +0100 | [diff] [blame] | 1312 | // JavaCoverageEnabledForPath returns whether Java code coverage is enabled for |
| 1313 | // path. Coverage is enabled by default when the product variable |
| 1314 | // JavaCoveragePaths is empty. If JavaCoveragePaths is not empty, coverage is |
| 1315 | // enabled for any path which is part of this variable (and not part of the |
| 1316 | // JavaCoverageExcludePaths product variable). Value "*" in JavaCoveragePaths |
| 1317 | // represents any path. |
| 1318 | func (c *deviceConfig) JavaCoverageEnabledForPath(path string) bool { |
| 1319 | coverage := false |
Chris Gross | 2f74869 | 2020-06-24 20:36:59 +0000 | [diff] [blame] | 1320 | if len(c.config.productVariables.JavaCoveragePaths) == 0 || |
Roland Levillain | ada1270 | 2020-06-09 13:07:36 +0100 | [diff] [blame] | 1321 | InList("*", c.config.productVariables.JavaCoveragePaths) || |
| 1322 | HasAnyPrefix(path, c.config.productVariables.JavaCoveragePaths) { |
| 1323 | coverage = true |
| 1324 | } |
Roland Levillain | f6cc261 | 2020-07-09 16:58:14 +0100 | [diff] [blame] | 1325 | if coverage && len(c.config.productVariables.JavaCoverageExcludePaths) > 0 { |
Roland Levillain | ada1270 | 2020-06-09 13:07:36 +0100 | [diff] [blame] | 1326 | if HasAnyPrefix(path, c.config.productVariables.JavaCoverageExcludePaths) { |
| 1327 | coverage = false |
| 1328 | } |
| 1329 | } |
| 1330 | return coverage |
| 1331 | } |
| 1332 | |
Colin Cross | 1a6acd4 | 2020-06-16 17:51:46 -0700 | [diff] [blame] | 1333 | // Returns true if gcov or clang coverage is enabled. |
Dan Willemsen | 581341d | 2017-02-09 16:16:31 -0800 | [diff] [blame] | 1334 | func (c *deviceConfig) NativeCoverageEnabled() bool { |
Colin Cross | 1a6acd4 | 2020-06-16 17:51:46 -0700 | [diff] [blame] | 1335 | return Bool(c.config.productVariables.GcovCoverage) || |
| 1336 | Bool(c.config.productVariables.ClangCoverage) |
Dan Willemsen | 581341d | 2017-02-09 16:16:31 -0800 | [diff] [blame] | 1337 | } |
| 1338 | |
Oliver Nguyen | 1382ab6 | 2019-12-06 15:22:41 -0800 | [diff] [blame] | 1339 | func (c *deviceConfig) ClangCoverageEnabled() bool { |
| 1340 | return Bool(c.config.productVariables.ClangCoverage) |
| 1341 | } |
| 1342 | |
Pirama Arumuga Nainar | b37ae58 | 2022-01-26 22:14:32 -0800 | [diff] [blame] | 1343 | func (c *deviceConfig) ClangCoverageContinuousMode() bool { |
| 1344 | return Bool(c.config.productVariables.ClangCoverageContinuousMode) |
| 1345 | } |
| 1346 | |
Colin Cross | 1a6acd4 | 2020-06-16 17:51:46 -0700 | [diff] [blame] | 1347 | func (c *deviceConfig) GcovCoverageEnabled() bool { |
| 1348 | return Bool(c.config.productVariables.GcovCoverage) |
| 1349 | } |
| 1350 | |
Roland Levillain | 4f5297b | 2020-06-09 12:44:06 +0100 | [diff] [blame] | 1351 | // NativeCoverageEnabledForPath returns whether (GCOV- or Clang-based) native |
| 1352 | // code coverage is enabled for path. By default, coverage is not enabled for a |
| 1353 | // given path unless it is part of the NativeCoveragePaths product variable (and |
| 1354 | // not part of the NativeCoverageExcludePaths product variable). Value "*" in |
| 1355 | // NativeCoveragePaths represents any path. |
| 1356 | func (c *deviceConfig) NativeCoverageEnabledForPath(path string) bool { |
Ryan Campbell | 469a18a | 2017-02-27 09:01:54 -0800 | [diff] [blame] | 1357 | coverage := false |
Roland Levillain | f6cc261 | 2020-07-09 16:58:14 +0100 | [diff] [blame] | 1358 | if len(c.config.productVariables.NativeCoveragePaths) > 0 { |
Roland Levillain | 4f5297b | 2020-06-09 12:44:06 +0100 | [diff] [blame] | 1359 | if InList("*", c.config.productVariables.NativeCoveragePaths) || HasAnyPrefix(path, c.config.productVariables.NativeCoveragePaths) { |
Ivan Lozano | 5f59553 | 2017-07-13 14:46:05 -0700 | [diff] [blame] | 1360 | coverage = true |
Dan Willemsen | 581341d | 2017-02-09 16:16:31 -0800 | [diff] [blame] | 1361 | } |
| 1362 | } |
Roland Levillain | f6cc261 | 2020-07-09 16:58:14 +0100 | [diff] [blame] | 1363 | if coverage && len(c.config.productVariables.NativeCoverageExcludePaths) > 0 { |
Yi Kong | 836690b | 2023-02-16 17:42:27 +0900 | [diff] [blame] | 1364 | // Workaround coverage boot failure. |
| 1365 | // http://b/269981180 |
| 1366 | if strings.HasPrefix(path, "external/protobuf") { |
| 1367 | coverage = false |
| 1368 | } |
Roland Levillain | 4f5297b | 2020-06-09 12:44:06 +0100 | [diff] [blame] | 1369 | if HasAnyPrefix(path, c.config.productVariables.NativeCoverageExcludePaths) { |
Ivan Lozano | 5f59553 | 2017-07-13 14:46:05 -0700 | [diff] [blame] | 1370 | coverage = false |
Ryan Campbell | 469a18a | 2017-02-27 09:01:54 -0800 | [diff] [blame] | 1371 | } |
| 1372 | } |
| 1373 | return coverage |
Dan Willemsen | 581341d | 2017-02-09 16:16:31 -0800 | [diff] [blame] | 1374 | } |
Ivan Lozano | 5f59553 | 2017-07-13 14:46:05 -0700 | [diff] [blame] | 1375 | |
Pirama Arumuga Nainar | 4954080 | 2018-01-29 23:11:42 -0800 | [diff] [blame] | 1376 | func (c *deviceConfig) PgoAdditionalProfileDirs() []string { |
Dan Willemsen | 45133ac | 2018-03-09 21:22:06 -0800 | [diff] [blame] | 1377 | return c.config.productVariables.PgoAdditionalProfileDirs |
Pirama Arumuga Nainar | 4954080 | 2018-01-29 23:11:42 -0800 | [diff] [blame] | 1378 | } |
| 1379 | |
Tri Vo | 35a5143 | 2018-03-25 20:00:00 -0700 | [diff] [blame] | 1380 | func (c *deviceConfig) VendorSepolicyDirs() []string { |
| 1381 | return c.config.productVariables.BoardVendorSepolicyDirs |
| 1382 | } |
| 1383 | |
| 1384 | func (c *deviceConfig) OdmSepolicyDirs() []string { |
| 1385 | return c.config.productVariables.BoardOdmSepolicyDirs |
| 1386 | } |
| 1387 | |
Felix | a20a875 | 2020-05-17 18:28:35 +0200 | [diff] [blame] | 1388 | func (c *deviceConfig) SystemExtPublicSepolicyDirs() []string { |
| 1389 | return c.config.productVariables.SystemExtPublicSepolicyDirs |
Tri Vo | 35a5143 | 2018-03-25 20:00:00 -0700 | [diff] [blame] | 1390 | } |
| 1391 | |
Felix | a20a875 | 2020-05-17 18:28:35 +0200 | [diff] [blame] | 1392 | func (c *deviceConfig) SystemExtPrivateSepolicyDirs() []string { |
| 1393 | return c.config.productVariables.SystemExtPrivateSepolicyDirs |
Tri Vo | 35a5143 | 2018-03-25 20:00:00 -0700 | [diff] [blame] | 1394 | } |
| 1395 | |
Inseob Kim | 0866b00 | 2019-04-15 20:21:29 +0900 | [diff] [blame] | 1396 | func (c *deviceConfig) SepolicyM4Defs() []string { |
| 1397 | return c.config.productVariables.BoardSepolicyM4Defs |
| 1398 | } |
| 1399 | |
Jiyong Park | 7f67f48 | 2019-01-05 12:57:48 +0900 | [diff] [blame] | 1400 | func (c *deviceConfig) OverrideManifestPackageNameFor(name string) (manifestName string, overridden bool) { |
Jaewoong Jung | 2ad817c | 2019-01-18 14:27:16 -0800 | [diff] [blame] | 1401 | return findOverrideValue(c.config.productVariables.ManifestPackageNameOverrides, name, |
| 1402 | "invalid override rule %q in PRODUCT_MANIFEST_PACKAGE_NAME_OVERRIDES should be <module_name>:<manifest_name>") |
| 1403 | } |
| 1404 | |
| 1405 | func (c *deviceConfig) OverrideCertificateFor(name string) (certificatePath string, overridden bool) { |
Jaewoong Jung | acb6db3 | 2019-02-28 16:22:30 +0000 | [diff] [blame] | 1406 | return findOverrideValue(c.config.productVariables.CertificateOverrides, name, |
Jaewoong Jung | 2ad817c | 2019-01-18 14:27:16 -0800 | [diff] [blame] | 1407 | "invalid override rule %q in PRODUCT_CERTIFICATE_OVERRIDES should be <module_name>:<certificate_module_name>") |
| 1408 | } |
| 1409 | |
Jaewoong Jung | 9d22a91 | 2019-01-23 16:27:47 -0800 | [diff] [blame] | 1410 | func (c *deviceConfig) OverridePackageNameFor(name string) string { |
| 1411 | newName, overridden := findOverrideValue( |
| 1412 | c.config.productVariables.PackageNameOverrides, |
| 1413 | name, |
| 1414 | "invalid override rule %q in PRODUCT_PACKAGE_NAME_OVERRIDES should be <module_name>:<package_name>") |
| 1415 | if overridden { |
| 1416 | return newName |
| 1417 | } |
| 1418 | return name |
| 1419 | } |
| 1420 | |
Jaewoong Jung | 2ad817c | 2019-01-18 14:27:16 -0800 | [diff] [blame] | 1421 | func findOverrideValue(overrides []string, name string, errorMsg string) (newValue string, overridden bool) { |
Jiyong Park | 7f67f48 | 2019-01-05 12:57:48 +0900 | [diff] [blame] | 1422 | if overrides == nil || len(overrides) == 0 { |
| 1423 | return "", false |
| 1424 | } |
| 1425 | for _, o := range overrides { |
| 1426 | split := strings.Split(o, ":") |
| 1427 | if len(split) != 2 { |
| 1428 | // This shouldn't happen as this is first checked in make, but just in case. |
Jaewoong Jung | 2ad817c | 2019-01-18 14:27:16 -0800 | [diff] [blame] | 1429 | panic(fmt.Errorf(errorMsg, o)) |
Jiyong Park | 7f67f48 | 2019-01-05 12:57:48 +0900 | [diff] [blame] | 1430 | } |
| 1431 | if matchPattern(split[0], name) { |
| 1432 | return substPattern(split[0], split[1], name), true |
| 1433 | } |
| 1434 | } |
| 1435 | return "", false |
| 1436 | } |
| 1437 | |
Albert Martin | eefabcf | 2022-03-21 20:11:16 +0000 | [diff] [blame] | 1438 | func (c *deviceConfig) ApexGlobalMinSdkVersionOverride() string { |
| 1439 | return String(c.config.productVariables.ApexGlobalMinSdkVersionOverride) |
| 1440 | } |
| 1441 | |
Ivan Lozano | 5f59553 | 2017-07-13 14:46:05 -0700 | [diff] [blame] | 1442 | func (c *config) IntegerOverflowDisabledForPath(path string) bool { |
Roland Levillain | f6cc261 | 2020-07-09 16:58:14 +0100 | [diff] [blame] | 1443 | if len(c.productVariables.IntegerOverflowExcludePaths) == 0 { |
Ivan Lozano | 5f59553 | 2017-07-13 14:46:05 -0700 | [diff] [blame] | 1444 | return false |
| 1445 | } |
Jaewoong Jung | 3aff578 | 2020-02-11 07:54:35 -0800 | [diff] [blame] | 1446 | return HasAnyPrefix(path, c.productVariables.IntegerOverflowExcludePaths) |
Ivan Lozano | 5f59553 | 2017-07-13 14:46:05 -0700 | [diff] [blame] | 1447 | } |
Vishwath Mohan | 1fa3ac5 | 2017-10-31 02:26:14 -0700 | [diff] [blame] | 1448 | |
| 1449 | func (c *config) CFIDisabledForPath(path string) bool { |
Roland Levillain | f6cc261 | 2020-07-09 16:58:14 +0100 | [diff] [blame] | 1450 | if len(c.productVariables.CFIExcludePaths) == 0 { |
Vishwath Mohan | 1fa3ac5 | 2017-10-31 02:26:14 -0700 | [diff] [blame] | 1451 | return false |
| 1452 | } |
Jaewoong Jung | 3aff578 | 2020-02-11 07:54:35 -0800 | [diff] [blame] | 1453 | return HasAnyPrefix(path, c.productVariables.CFIExcludePaths) |
Vishwath Mohan | 1fa3ac5 | 2017-10-31 02:26:14 -0700 | [diff] [blame] | 1454 | } |
| 1455 | |
| 1456 | func (c *config) CFIEnabledForPath(path string) bool { |
Roland Levillain | f6cc261 | 2020-07-09 16:58:14 +0100 | [diff] [blame] | 1457 | if len(c.productVariables.CFIIncludePaths) == 0 { |
Vishwath Mohan | 1fa3ac5 | 2017-10-31 02:26:14 -0700 | [diff] [blame] | 1458 | return false |
| 1459 | } |
Evgenii Stepanov | 779b64e | 2021-04-09 14:33:10 -0700 | [diff] [blame] | 1460 | return HasAnyPrefix(path, c.productVariables.CFIIncludePaths) && !c.CFIDisabledForPath(path) |
Vishwath Mohan | 1fa3ac5 | 2017-10-31 02:26:14 -0700 | [diff] [blame] | 1461 | } |
Colin Cross | e15ddaf | 2017-12-04 11:24:31 -0800 | [diff] [blame] | 1462 | |
Evgenii Stepanov | 4beaa0c | 2021-01-05 16:41:26 -0800 | [diff] [blame] | 1463 | func (c *config) MemtagHeapDisabledForPath(path string) bool { |
| 1464 | if len(c.productVariables.MemtagHeapExcludePaths) == 0 { |
| 1465 | return false |
| 1466 | } |
| 1467 | return HasAnyPrefix(path, c.productVariables.MemtagHeapExcludePaths) |
| 1468 | } |
| 1469 | |
| 1470 | func (c *config) MemtagHeapAsyncEnabledForPath(path string) bool { |
| 1471 | if len(c.productVariables.MemtagHeapAsyncIncludePaths) == 0 { |
| 1472 | return false |
| 1473 | } |
Evgenii Stepanov | 779b64e | 2021-04-09 14:33:10 -0700 | [diff] [blame] | 1474 | return HasAnyPrefix(path, c.productVariables.MemtagHeapAsyncIncludePaths) && !c.MemtagHeapDisabledForPath(path) |
Evgenii Stepanov | 4beaa0c | 2021-01-05 16:41:26 -0800 | [diff] [blame] | 1475 | } |
| 1476 | |
| 1477 | func (c *config) MemtagHeapSyncEnabledForPath(path string) bool { |
| 1478 | if len(c.productVariables.MemtagHeapSyncIncludePaths) == 0 { |
| 1479 | return false |
| 1480 | } |
Evgenii Stepanov | 779b64e | 2021-04-09 14:33:10 -0700 | [diff] [blame] | 1481 | return HasAnyPrefix(path, c.productVariables.MemtagHeapSyncIncludePaths) && !c.MemtagHeapDisabledForPath(path) |
Evgenii Stepanov | 4beaa0c | 2021-01-05 16:41:26 -0800 | [diff] [blame] | 1482 | } |
| 1483 | |
Dan Willemsen | 0fe7866 | 2018-03-26 12:41:18 -0700 | [diff] [blame] | 1484 | func (c *config) VendorConfig(name string) VendorConfig { |
Colin Cross | 9d34f35 | 2019-11-22 16:03:51 -0800 | [diff] [blame] | 1485 | return soongconfig.Config(c.productVariables.VendorVars[name]) |
Dan Willemsen | 0fe7866 | 2018-03-26 12:41:18 -0700 | [diff] [blame] | 1486 | } |
| 1487 | |
Colin Cross | 395f2cf | 2018-10-24 16:10:32 -0700 | [diff] [blame] | 1488 | func (c *config) NdkAbis() bool { |
| 1489 | return Bool(c.productVariables.Ndk_abis) |
| 1490 | } |
| 1491 | |
Martin Stjernholm | c1ecc43 | 2019-11-15 15:00:31 +0000 | [diff] [blame] | 1492 | func (c *config) AmlAbis() bool { |
| 1493 | return Bool(c.productVariables.Aml_abis) |
| 1494 | } |
| 1495 | |
Jiyong Park | 8fd6192 | 2018-11-08 02:50:25 +0900 | [diff] [blame] | 1496 | func (c *config) FlattenApex() bool { |
Roland Levillain | a386321 | 2019-08-12 19:56:16 +0100 | [diff] [blame] | 1497 | return Bool(c.productVariables.Flatten_apex) |
Jiyong Park | 8fd6192 | 2018-11-08 02:50:25 +0900 | [diff] [blame] | 1498 | } |
| 1499 | |
Jiyong Park | 4da0797 | 2021-01-05 21:01:11 +0900 | [diff] [blame] | 1500 | func (c *config) ForceApexSymlinkOptimization() bool { |
| 1501 | return Bool(c.productVariables.ForceApexSymlinkOptimization) |
| 1502 | } |
| 1503 | |
Sasha Smundak | fe9a5b8 | 2022-07-27 14:51:45 -0700 | [diff] [blame] | 1504 | func (c *config) ApexCompressionEnabled() bool { |
| 1505 | return Bool(c.productVariables.CompressedApex) && !c.UnbundledBuildApps() |
Mohammad Samiul Islam | 3cd005d | 2020-11-26 13:32:26 +0000 | [diff] [blame] | 1506 | } |
| 1507 | |
Dennis Shen | e2ed70c | 2023-01-11 14:15:43 +0000 | [diff] [blame] | 1508 | func (c *config) ApexTrimEnabled() bool { |
| 1509 | return Bool(c.productVariables.TrimmedApex) |
| 1510 | } |
| 1511 | |
Jeongik Cha | c946414 | 2019-01-07 12:07:27 +0900 | [diff] [blame] | 1512 | func (c *config) EnforceSystemCertificate() bool { |
| 1513 | return Bool(c.productVariables.EnforceSystemCertificate) |
| 1514 | } |
| 1515 | |
Colin Cross | 440e0d0 | 2020-06-11 11:32:11 -0700 | [diff] [blame] | 1516 | func (c *config) EnforceSystemCertificateAllowList() []string { |
| 1517 | return c.productVariables.EnforceSystemCertificateAllowList |
Jeongik Cha | c946414 | 2019-01-07 12:07:27 +0900 | [diff] [blame] | 1518 | } |
| 1519 | |
Jeongik Cha | 2cc570d | 2019-10-29 15:44:45 +0900 | [diff] [blame] | 1520 | func (c *config) EnforceProductPartitionInterface() bool { |
| 1521 | return Bool(c.productVariables.EnforceProductPartitionInterface) |
| 1522 | } |
| 1523 | |
JaeMan Park | ff71556 | 2020-10-19 17:25:58 +0900 | [diff] [blame] | 1524 | func (c *config) EnforceInterPartitionJavaSdkLibrary() bool { |
| 1525 | return Bool(c.productVariables.EnforceInterPartitionJavaSdkLibrary) |
| 1526 | } |
| 1527 | |
| 1528 | func (c *config) InterPartitionJavaLibraryAllowList() []string { |
| 1529 | return c.productVariables.InterPartitionJavaLibraryAllowList |
| 1530 | } |
| 1531 | |
Jooyung Han | 3ab2c3e | 2019-12-05 16:27:44 +0900 | [diff] [blame] | 1532 | func (c *config) InstallExtraFlattenedApexes() bool { |
| 1533 | return Bool(c.productVariables.InstallExtraFlattenedApexes) |
| 1534 | } |
| 1535 | |
Colin Cross | f24a22a | 2019-01-31 14:12:44 -0800 | [diff] [blame] | 1536 | func (c *config) ProductHiddenAPIStubs() []string { |
| 1537 | return c.productVariables.ProductHiddenAPIStubs |
Colin Cross | 8faf8fc | 2019-01-16 15:15:52 -0800 | [diff] [blame] | 1538 | } |
| 1539 | |
Colin Cross | f24a22a | 2019-01-31 14:12:44 -0800 | [diff] [blame] | 1540 | func (c *config) ProductHiddenAPIStubsSystem() []string { |
| 1541 | return c.productVariables.ProductHiddenAPIStubsSystem |
Colin Cross | 8faf8fc | 2019-01-16 15:15:52 -0800 | [diff] [blame] | 1542 | } |
| 1543 | |
Colin Cross | f24a22a | 2019-01-31 14:12:44 -0800 | [diff] [blame] | 1544 | func (c *config) ProductHiddenAPIStubsTest() []string { |
| 1545 | return c.productVariables.ProductHiddenAPIStubsTest |
Colin Cross | 8faf8fc | 2019-01-16 15:15:52 -0800 | [diff] [blame] | 1546 | } |
Dan Willemsen | 71c7460 | 2019-04-10 12:27:35 -0700 | [diff] [blame] | 1547 | |
Dan Willemsen | 54879d1 | 2019-04-18 10:08:46 -0700 | [diff] [blame] | 1548 | func (c *deviceConfig) TargetFSConfigGen() []string { |
Dan Willemsen | 71c7460 | 2019-04-10 12:27:35 -0700 | [diff] [blame] | 1549 | return c.config.productVariables.TargetFSConfigGen |
| 1550 | } |
Inseob Kim | 0866b00 | 2019-04-15 20:21:29 +0900 | [diff] [blame] | 1551 | |
| 1552 | func (c *config) ProductPublicSepolicyDirs() []string { |
| 1553 | return c.productVariables.ProductPublicSepolicyDirs |
| 1554 | } |
| 1555 | |
| 1556 | func (c *config) ProductPrivateSepolicyDirs() []string { |
| 1557 | return c.productVariables.ProductPrivateSepolicyDirs |
| 1558 | } |
| 1559 | |
Colin Cross | 50ddcc4 | 2019-05-16 12:28:22 -0700 | [diff] [blame] | 1560 | func (c *config) MissingUsesLibraries() []string { |
| 1561 | return c.productVariables.MissingUsesLibraries |
| 1562 | } |
| 1563 | |
Inseob Kim | 5eb7ee9 | 2022-04-27 10:30:34 +0900 | [diff] [blame] | 1564 | func (c *config) TargetMultitreeUpdateMeta() bool { |
| 1565 | return c.productVariables.MultitreeUpdateMeta |
| 1566 | } |
| 1567 | |
Inseob Kim | 1f086e2 | 2019-05-09 13:29:15 +0900 | [diff] [blame] | 1568 | func (c *deviceConfig) DeviceArch() string { |
| 1569 | return String(c.config.productVariables.DeviceArch) |
| 1570 | } |
| 1571 | |
| 1572 | func (c *deviceConfig) DeviceArchVariant() string { |
| 1573 | return String(c.config.productVariables.DeviceArchVariant) |
| 1574 | } |
| 1575 | |
| 1576 | func (c *deviceConfig) DeviceSecondaryArch() string { |
| 1577 | return String(c.config.productVariables.DeviceSecondaryArch) |
| 1578 | } |
| 1579 | |
| 1580 | func (c *deviceConfig) DeviceSecondaryArchVariant() string { |
| 1581 | return String(c.config.productVariables.DeviceSecondaryArchVariant) |
| 1582 | } |
Yifan Hong | 82db735 | 2020-01-21 16:12:26 -0800 | [diff] [blame] | 1583 | |
| 1584 | func (c *deviceConfig) BoardUsesRecoveryAsBoot() bool { |
| 1585 | return Bool(c.config.productVariables.BoardUsesRecoveryAsBoot) |
| 1586 | } |
Yifan Hong | 97365ee | 2020-07-29 09:51:57 -0700 | [diff] [blame] | 1587 | |
| 1588 | func (c *deviceConfig) BoardKernelBinaries() []string { |
| 1589 | return c.config.productVariables.BoardKernelBinaries |
| 1590 | } |
Ulya Trafimovich | 249386a | 2020-07-01 14:31:13 +0100 | [diff] [blame] | 1591 | |
Yifan Hong | 42bef8d | 2020-08-05 14:36:09 -0700 | [diff] [blame] | 1592 | func (c *deviceConfig) BoardKernelModuleInterfaceVersions() []string { |
| 1593 | return c.config.productVariables.BoardKernelModuleInterfaceVersions |
| 1594 | } |
| 1595 | |
Yifan Hong | dd8dacc | 2020-10-21 15:40:17 -0700 | [diff] [blame] | 1596 | func (c *deviceConfig) BoardMoveRecoveryResourcesToVendorBoot() bool { |
| 1597 | return Bool(c.config.productVariables.BoardMoveRecoveryResourcesToVendorBoot) |
| 1598 | } |
| 1599 | |
Inseob Kim | 16ebd5a | 2020-12-09 23:08:17 +0900 | [diff] [blame] | 1600 | func (c *deviceConfig) PlatformSepolicyVersion() string { |
| 1601 | return String(c.config.productVariables.PlatformSepolicyVersion) |
| 1602 | } |
| 1603 | |
Inseob Kim | a10ef27 | 2021-09-15 03:04:53 +0000 | [diff] [blame] | 1604 | func (c *deviceConfig) TotSepolicyVersion() string { |
| 1605 | return String(c.config.productVariables.TotSepolicyVersion) |
| 1606 | } |
| 1607 | |
Inseob Kim | 843f664 | 2022-01-07 09:11:23 +0900 | [diff] [blame] | 1608 | func (c *deviceConfig) PlatformSepolicyCompatVersions() []string { |
| 1609 | return c.config.productVariables.PlatformSepolicyCompatVersions |
| 1610 | } |
| 1611 | |
Inseob Kim | 16ebd5a | 2020-12-09 23:08:17 +0900 | [diff] [blame] | 1612 | func (c *deviceConfig) BoardSepolicyVers() string { |
Inseob Kim | 0c4eec8 | 2021-03-22 22:33:40 +0900 | [diff] [blame] | 1613 | if ver := String(c.config.productVariables.BoardSepolicyVers); ver != "" { |
| 1614 | return ver |
| 1615 | } |
| 1616 | return c.PlatformSepolicyVersion() |
Inseob Kim | 16ebd5a | 2020-12-09 23:08:17 +0900 | [diff] [blame] | 1617 | } |
| 1618 | |
Inseob Kim | 1417880 | 2021-12-08 22:53:31 +0900 | [diff] [blame] | 1619 | func (c *deviceConfig) BoardPlatVendorPolicy() []string { |
| 1620 | return c.config.productVariables.BoardPlatVendorPolicy |
| 1621 | } |
| 1622 | |
Inseob Kim | 16ebd5a | 2020-12-09 23:08:17 +0900 | [diff] [blame] | 1623 | func (c *deviceConfig) BoardReqdMaskPolicy() []string { |
| 1624 | return c.config.productVariables.BoardReqdMaskPolicy |
| 1625 | } |
| 1626 | |
Inseob Kim | 0f46e7c | 2021-12-15 22:48:14 +0900 | [diff] [blame] | 1627 | func (c *deviceConfig) BoardSystemExtPublicPrebuiltDirs() []string { |
| 1628 | return c.config.productVariables.BoardSystemExtPublicPrebuiltDirs |
| 1629 | } |
| 1630 | |
| 1631 | func (c *deviceConfig) BoardSystemExtPrivatePrebuiltDirs() []string { |
| 1632 | return c.config.productVariables.BoardSystemExtPrivatePrebuiltDirs |
| 1633 | } |
| 1634 | |
| 1635 | func (c *deviceConfig) BoardProductPublicPrebuiltDirs() []string { |
| 1636 | return c.config.productVariables.BoardProductPublicPrebuiltDirs |
| 1637 | } |
| 1638 | |
| 1639 | func (c *deviceConfig) BoardProductPrivatePrebuiltDirs() []string { |
| 1640 | return c.config.productVariables.BoardProductPrivatePrebuiltDirs |
| 1641 | } |
| 1642 | |
Inseob Kim | 1a0afcc | 2022-02-14 23:10:51 +0900 | [diff] [blame] | 1643 | func (c *deviceConfig) SystemExtSepolicyPrebuiltApiDir() string { |
| 1644 | return String(c.config.productVariables.SystemExtSepolicyPrebuiltApiDir) |
| 1645 | } |
| 1646 | |
| 1647 | func (c *deviceConfig) ProductSepolicyPrebuiltApiDir() string { |
| 1648 | return String(c.config.productVariables.ProductSepolicyPrebuiltApiDir) |
| 1649 | } |
| 1650 | |
| 1651 | func (c *deviceConfig) IsPartnerTrebleSepolicyTestEnabled() bool { |
| 1652 | return c.SystemExtSepolicyPrebuiltApiDir() != "" || c.ProductSepolicyPrebuiltApiDir() != "" |
| 1653 | } |
| 1654 | |
Inseob Kim | 7cf1465 | 2021-01-06 23:06:52 +0900 | [diff] [blame] | 1655 | func (c *deviceConfig) DirectedVendorSnapshot() bool { |
| 1656 | return c.config.productVariables.DirectedVendorSnapshot |
| 1657 | } |
| 1658 | |
| 1659 | func (c *deviceConfig) VendorSnapshotModules() map[string]bool { |
| 1660 | return c.config.productVariables.VendorSnapshotModules |
| 1661 | } |
| 1662 | |
Jose Galmes | 4c6895e | 2021-02-09 07:44:30 -0800 | [diff] [blame] | 1663 | func (c *deviceConfig) DirectedRecoverySnapshot() bool { |
| 1664 | return c.config.productVariables.DirectedRecoverySnapshot |
| 1665 | } |
| 1666 | |
| 1667 | func (c *deviceConfig) RecoverySnapshotModules() map[string]bool { |
| 1668 | return c.config.productVariables.RecoverySnapshotModules |
| 1669 | } |
| 1670 | |
Justin DeMartino | 383bfb3 | 2021-02-24 10:49:43 -0800 | [diff] [blame] | 1671 | func createDirsMap(previous map[string]bool, dirs []string) (map[string]bool, error) { |
| 1672 | var ret = make(map[string]bool) |
| 1673 | for _, dir := range dirs { |
| 1674 | clean := filepath.Clean(dir) |
| 1675 | if previous[clean] || ret[clean] { |
| 1676 | return nil, fmt.Errorf("Duplicate entry %s", dir) |
| 1677 | } |
| 1678 | ret[clean] = true |
| 1679 | } |
| 1680 | return ret, nil |
| 1681 | } |
| 1682 | |
| 1683 | func (c *deviceConfig) createDirsMapOnce(onceKey OnceKey, previous map[string]bool, dirs []string) map[string]bool { |
| 1684 | dirMap := c.Once(onceKey, func() interface{} { |
| 1685 | ret, err := createDirsMap(previous, dirs) |
| 1686 | if err != nil { |
| 1687 | panic(fmt.Errorf("%s: %w", onceKey.key, err)) |
| 1688 | } |
| 1689 | return ret |
| 1690 | }) |
| 1691 | if dirMap == nil { |
| 1692 | return nil |
| 1693 | } |
| 1694 | return dirMap.(map[string]bool) |
| 1695 | } |
| 1696 | |
| 1697 | var vendorSnapshotDirsExcludedKey = NewOnceKey("VendorSnapshotDirsExcludedMap") |
| 1698 | |
| 1699 | func (c *deviceConfig) VendorSnapshotDirsExcludedMap() map[string]bool { |
| 1700 | return c.createDirsMapOnce(vendorSnapshotDirsExcludedKey, nil, |
| 1701 | c.config.productVariables.VendorSnapshotDirsExcluded) |
| 1702 | } |
| 1703 | |
| 1704 | var vendorSnapshotDirsIncludedKey = NewOnceKey("VendorSnapshotDirsIncludedMap") |
| 1705 | |
| 1706 | func (c *deviceConfig) VendorSnapshotDirsIncludedMap() map[string]bool { |
| 1707 | excludedMap := c.VendorSnapshotDirsExcludedMap() |
| 1708 | return c.createDirsMapOnce(vendorSnapshotDirsIncludedKey, excludedMap, |
| 1709 | c.config.productVariables.VendorSnapshotDirsIncluded) |
| 1710 | } |
| 1711 | |
| 1712 | var recoverySnapshotDirsExcludedKey = NewOnceKey("RecoverySnapshotDirsExcludedMap") |
| 1713 | |
| 1714 | func (c *deviceConfig) RecoverySnapshotDirsExcludedMap() map[string]bool { |
| 1715 | return c.createDirsMapOnce(recoverySnapshotDirsExcludedKey, nil, |
| 1716 | c.config.productVariables.RecoverySnapshotDirsExcluded) |
| 1717 | } |
| 1718 | |
| 1719 | var recoverySnapshotDirsIncludedKey = NewOnceKey("RecoverySnapshotDirsIncludedMap") |
| 1720 | |
| 1721 | func (c *deviceConfig) RecoverySnapshotDirsIncludedMap() map[string]bool { |
| 1722 | excludedMap := c.RecoverySnapshotDirsExcludedMap() |
| 1723 | return c.createDirsMapOnce(recoverySnapshotDirsIncludedKey, excludedMap, |
| 1724 | c.config.productVariables.RecoverySnapshotDirsIncluded) |
| 1725 | } |
| 1726 | |
Rob Seymour | 925aa09 | 2021-08-10 20:42:03 +0000 | [diff] [blame] | 1727 | func (c *deviceConfig) HostFakeSnapshotEnabled() bool { |
| 1728 | return c.config.productVariables.HostFakeSnapshotEnabled |
| 1729 | } |
| 1730 | |
Inseob Kim | 60c32f0 | 2020-12-21 22:53:05 +0900 | [diff] [blame] | 1731 | func (c *deviceConfig) ShippingApiLevel() ApiLevel { |
| 1732 | if c.config.productVariables.ShippingApiLevel == nil { |
| 1733 | return NoneApiLevel |
| 1734 | } |
| 1735 | apiLevel, _ := strconv.Atoi(*c.config.productVariables.ShippingApiLevel) |
| 1736 | return uncheckedFinalApiLevel(apiLevel) |
| 1737 | } |
| 1738 | |
Alix Espino | ef47e54 | 2022-09-14 19:10:51 +0000 | [diff] [blame] | 1739 | func (c *deviceConfig) BuildBrokenClangAsFlags() bool { |
| 1740 | return c.config.productVariables.BuildBrokenClangAsFlags |
| 1741 | } |
| 1742 | |
| 1743 | func (c *deviceConfig) BuildBrokenClangCFlags() bool { |
| 1744 | return c.config.productVariables.BuildBrokenClangCFlags |
| 1745 | } |
| 1746 | |
Alix | b5f6d9e | 2022-04-20 23:00:58 +0000 | [diff] [blame] | 1747 | func (c *deviceConfig) BuildBrokenClangProperty() bool { |
| 1748 | return c.config.productVariables.BuildBrokenClangProperty |
| 1749 | } |
| 1750 | |
Inseob Kim | 67e5add | 2021-03-17 18:05:33 +0900 | [diff] [blame] | 1751 | func (c *deviceConfig) BuildBrokenEnforceSyspropOwner() bool { |
| 1752 | return c.config.productVariables.BuildBrokenEnforceSyspropOwner |
| 1753 | } |
| 1754 | |
| 1755 | func (c *deviceConfig) BuildBrokenTrebleSyspropNeverallow() bool { |
| 1756 | return c.config.productVariables.BuildBrokenTrebleSyspropNeverallow |
| 1757 | } |
| 1758 | |
Hridya Valsaraju | 5a5c7d5 | 2021-04-02 16:45:24 -0700 | [diff] [blame] | 1759 | func (c *deviceConfig) BuildDebugfsRestrictionsEnabled() bool { |
| 1760 | return c.config.productVariables.BuildDebugfsRestrictionsEnabled |
| 1761 | } |
| 1762 | |
Inseob Kim | 0cac7b4 | 2021-02-03 18:16:46 +0900 | [diff] [blame] | 1763 | func (c *deviceConfig) BuildBrokenVendorPropertyNamespace() bool { |
| 1764 | return c.config.productVariables.BuildBrokenVendorPropertyNamespace |
| 1765 | } |
| 1766 | |
Liz Kammer | 619be46 | 2022-01-28 15:13:39 -0500 | [diff] [blame] | 1767 | func (c *deviceConfig) BuildBrokenInputDir(name string) bool { |
| 1768 | return InList(name, c.config.productVariables.BuildBrokenInputDirModules) |
| 1769 | } |
| 1770 | |
Vinh Tran | 140d588 | 2022-06-10 14:23:27 -0400 | [diff] [blame] | 1771 | func (c *deviceConfig) BuildBrokenDepfile() bool { |
| 1772 | return Bool(c.config.productVariables.BuildBrokenDepfile) |
| 1773 | } |
| 1774 | |
Inseob Kim | 67e5add | 2021-03-17 18:05:33 +0900 | [diff] [blame] | 1775 | func (c *deviceConfig) RequiresInsecureExecmemForSwiftshader() bool { |
| 1776 | return c.config.productVariables.RequiresInsecureExecmemForSwiftshader |
| 1777 | } |
| 1778 | |
| 1779 | func (c *config) SelinuxIgnoreNeverallows() bool { |
| 1780 | return c.productVariables.SelinuxIgnoreNeverallows |
| 1781 | } |
| 1782 | |
| 1783 | func (c *deviceConfig) SepolicySplit() bool { |
| 1784 | return c.config.productVariables.SepolicySplit |
| 1785 | } |
| 1786 | |
Inseob Kim | a10ef27 | 2021-09-15 03:04:53 +0000 | [diff] [blame] | 1787 | func (c *deviceConfig) SepolicyFreezeTestExtraDirs() []string { |
| 1788 | return c.config.productVariables.SepolicyFreezeTestExtraDirs |
| 1789 | } |
| 1790 | |
| 1791 | func (c *deviceConfig) SepolicyFreezeTestExtraPrebuiltDirs() []string { |
| 1792 | return c.config.productVariables.SepolicyFreezeTestExtraPrebuiltDirs |
| 1793 | } |
| 1794 | |
Jiyong Park | d163d4d | 2021-10-12 16:47:43 +0900 | [diff] [blame] | 1795 | func (c *deviceConfig) GenerateAidlNdkPlatformBackend() bool { |
| 1796 | return c.config.productVariables.GenerateAidlNdkPlatformBackend |
| 1797 | } |
| 1798 | |
Christopher Ferris | 98f1022 | 2022-07-13 23:16:52 -0700 | [diff] [blame] | 1799 | func (c *config) IgnorePrefer32OnDevice() bool { |
| 1800 | return c.productVariables.IgnorePrefer32OnDevice |
| 1801 | } |
| 1802 | |
Ulya Trafimovich | 249386a | 2020-07-01 14:31:13 +0100 | [diff] [blame] | 1803 | func (c *config) BootJars() []string { |
| 1804 | return c.Once(earlyBootJarsKey, func() interface{} { |
Paul Duffin | 69d1fb1 | 2020-10-23 21:14:20 +0100 | [diff] [blame] | 1805 | list := c.productVariables.BootJars.CopyOfJars() |
satayev | d604b21 | 2021-07-21 14:23:52 +0100 | [diff] [blame] | 1806 | return append(list, c.productVariables.ApexBootJars.CopyOfJars()...) |
Ulya Trafimovich | 249386a | 2020-07-01 14:31:13 +0100 | [diff] [blame] | 1807 | }).([]string) |
| 1808 | } |
Paul Duffin | 9a89a2a | 2020-10-28 19:20:06 +0000 | [diff] [blame] | 1809 | |
satayev | d604b21 | 2021-07-21 14:23:52 +0100 | [diff] [blame] | 1810 | func (c *config) NonApexBootJars() ConfiguredJarList { |
Paul Duffin | 9a89a2a | 2020-10-28 19:20:06 +0000 | [diff] [blame] | 1811 | return c.productVariables.BootJars |
| 1812 | } |
| 1813 | |
satayev | d604b21 | 2021-07-21 14:23:52 +0100 | [diff] [blame] | 1814 | func (c *config) ApexBootJars() ConfiguredJarList { |
| 1815 | return c.productVariables.ApexBootJars |
Paul Duffin | 9a89a2a | 2020-10-28 19:20:06 +0000 | [diff] [blame] | 1816 | } |
Colin Cross | 77cdcfd | 2021-03-12 11:28:25 -0800 | [diff] [blame] | 1817 | |
| 1818 | func (c *config) RBEWrapper() string { |
| 1819 | return c.GetenvWithDefault("RBE_WRAPPER", remoteexec.DefaultWrapperPath) |
| 1820 | } |
Colin Cross | 9b698b6 | 2021-12-22 09:55:32 -0800 | [diff] [blame] | 1821 | |
| 1822 | // UseHostMusl returns true if the host target has been configured to build against musl libc. |
| 1823 | func (c *config) UseHostMusl() bool { |
| 1824 | return Bool(c.productVariables.HostMusl) |
| 1825 | } |
MarkDacek | ff851b8 | 2022-04-21 18:33:17 +0000 | [diff] [blame] | 1826 | |
Chris Parsons | f874e46 | 2022-05-10 13:50:12 -0400 | [diff] [blame] | 1827 | func (c *config) LogMixedBuild(ctx BaseModuleContext, useBazel bool) { |
MarkDacek | ff851b8 | 2022-04-21 18:33:17 +0000 | [diff] [blame] | 1828 | moduleName := ctx.Module().Name() |
| 1829 | c.mixedBuildsLock.Lock() |
| 1830 | defer c.mixedBuildsLock.Unlock() |
| 1831 | if useBazel { |
| 1832 | c.mixedBuildEnabledModules[moduleName] = struct{}{} |
| 1833 | } else { |
| 1834 | c.mixedBuildDisabledModules[moduleName] = struct{}{} |
| 1835 | } |
| 1836 | } |