override_module.go 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378
  1. // Copyright (C) 2019 The Android Open Source Project
  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. package android
  15. // This file contains all the foundation components for override modules and their base module
  16. // types. Override modules are a kind of opposite of default modules in that they override certain
  17. // properties of an existing base module whereas default modules provide base module data to be
  18. // overridden. However, unlike default and defaultable module pairs, both override and overridable
  19. // modules generate and output build actions, and it is up to product make vars to decide which one
  20. // to actually build and install in the end. In other words, default modules and defaultable modules
  21. // can be compared to abstract classes and concrete classes in C++ and Java. By the same analogy,
  22. // both override and overridable modules act like concrete classes.
  23. //
  24. // There is one more crucial difference from the logic perspective. Unlike default pairs, most Soong
  25. // actions happen in the base (overridable) module by creating a local variant for each override
  26. // module based on it.
  27. import (
  28. "sort"
  29. "sync"
  30. "github.com/google/blueprint"
  31. "github.com/google/blueprint/proptools"
  32. )
  33. // Interface for override module types, e.g. override_android_app, override_apex
  34. type OverrideModule interface {
  35. Module
  36. getOverridingProperties() []interface{}
  37. setOverridingProperties(properties []interface{})
  38. getOverrideModuleProperties() *OverrideModuleProperties
  39. // Internal funcs to handle interoperability between override modules and prebuilts.
  40. // i.e. cases where an overriding module, too, is overridden by a prebuilt module.
  41. setOverriddenByPrebuilt(prebuilt Module)
  42. getOverriddenByPrebuilt() Module
  43. // Directory containing the Blueprint definition of the overriding module
  44. setModuleDir(string)
  45. ModuleDir() string
  46. }
  47. // Base module struct for override module types
  48. type OverrideModuleBase struct {
  49. moduleProperties OverrideModuleProperties
  50. overridingProperties []interface{}
  51. overriddenByPrebuilt Module
  52. moduleDir string
  53. }
  54. type OverrideModuleProperties struct {
  55. // Name of the base module to be overridden
  56. Base *string
  57. // TODO(jungjw): Add an optional override_name bool flag.
  58. }
  59. func (o *OverrideModuleBase) setModuleDir(d string) {
  60. o.moduleDir = d
  61. }
  62. func (o *OverrideModuleBase) ModuleDir() string {
  63. return o.moduleDir
  64. }
  65. func (o *OverrideModuleBase) getOverridingProperties() []interface{} {
  66. return o.overridingProperties
  67. }
  68. func (o *OverrideModuleBase) setOverridingProperties(properties []interface{}) {
  69. o.overridingProperties = properties
  70. }
  71. func (o *OverrideModuleBase) getOverrideModuleProperties() *OverrideModuleProperties {
  72. return &o.moduleProperties
  73. }
  74. func (o *OverrideModuleBase) GetOverriddenModuleName() string {
  75. return proptools.String(o.moduleProperties.Base)
  76. }
  77. func (o *OverrideModuleBase) setOverriddenByPrebuilt(prebuilt Module) {
  78. o.overriddenByPrebuilt = prebuilt
  79. }
  80. func (o *OverrideModuleBase) getOverriddenByPrebuilt() Module {
  81. return o.overriddenByPrebuilt
  82. }
  83. func InitOverrideModule(m OverrideModule) {
  84. m.setOverridingProperties(m.GetProperties())
  85. m.AddProperties(m.getOverrideModuleProperties())
  86. }
  87. // Interface for overridable module types, e.g. android_app, apex
  88. type OverridableModule interface {
  89. Module
  90. moduleBase() *OverridableModuleBase
  91. setOverridableProperties(prop []interface{})
  92. addOverride(o OverrideModule)
  93. getOverrides() []OverrideModule
  94. override(ctx BaseModuleContext, m Module, o OverrideModule)
  95. GetOverriddenBy() string
  96. GetOverriddenByModuleDir() string
  97. setOverridesProperty(overridesProperties *[]string)
  98. // Due to complications with incoming dependencies, overrides are processed after DepsMutator.
  99. // So, overridable properties need to be handled in a separate, dedicated deps mutator.
  100. OverridablePropertiesDepsMutator(ctx BottomUpMutatorContext)
  101. }
  102. type overridableModuleProperties struct {
  103. OverriddenBy string `blueprint:"mutated"`
  104. OverriddenByModuleDir string `blueprint:"mutated"`
  105. }
  106. // Base module struct for overridable module types
  107. type OverridableModuleBase struct {
  108. // List of OverrideModules that override this base module
  109. overrides []OverrideModule
  110. // Used to parallelize registerOverrideMutator executions. Note that only addOverride locks this
  111. // mutex. It is because addOverride and getOverride are used in different mutators, and so are
  112. // guaranteed to be not mixed. (And, getOverride only reads from overrides, and so don't require
  113. // mutex locking.)
  114. overridesLock sync.Mutex
  115. overridableProperties []interface{}
  116. // If an overridable module has a property to list other modules that itself overrides, it should
  117. // set this to a pointer to the property through the InitOverridableModule function, so that
  118. // override information is propagated and aggregated correctly.
  119. overridesProperty *[]string
  120. overridableModuleProperties overridableModuleProperties
  121. }
  122. func InitOverridableModule(m OverridableModule, overridesProperty *[]string) {
  123. m.setOverridableProperties(m.(Module).GetProperties())
  124. m.setOverridesProperty(overridesProperty)
  125. m.AddProperties(&m.moduleBase().overridableModuleProperties)
  126. }
  127. func (o *OverridableModuleBase) moduleBase() *OverridableModuleBase {
  128. return o
  129. }
  130. func (b *OverridableModuleBase) setOverridableProperties(prop []interface{}) {
  131. b.overridableProperties = prop
  132. }
  133. func (b *OverridableModuleBase) addOverride(o OverrideModule) {
  134. b.overridesLock.Lock()
  135. b.overrides = append(b.overrides, o)
  136. b.overridesLock.Unlock()
  137. }
  138. // Should NOT be used in the same mutator as addOverride.
  139. func (b *OverridableModuleBase) getOverrides() []OverrideModule {
  140. b.overridesLock.Lock()
  141. sort.Slice(b.overrides, func(i, j int) bool {
  142. return b.overrides[i].Name() < b.overrides[j].Name()
  143. })
  144. b.overridesLock.Unlock()
  145. return b.overrides
  146. }
  147. func (b *OverridableModuleBase) setOverridesProperty(overridesProperty *[]string) {
  148. b.overridesProperty = overridesProperty
  149. }
  150. // Overrides a base module with the given OverrideModule.
  151. func (b *OverridableModuleBase) override(ctx BaseModuleContext, m Module, o OverrideModule) {
  152. for _, p := range b.overridableProperties {
  153. for _, op := range o.getOverridingProperties() {
  154. if proptools.TypeEqual(p, op) {
  155. err := proptools.ExtendProperties(p, op, nil, proptools.OrderReplace)
  156. if err != nil {
  157. if propertyErr, ok := err.(*proptools.ExtendPropertyError); ok {
  158. ctx.PropertyErrorf(propertyErr.Property, "%s", propertyErr.Err.Error())
  159. } else {
  160. panic(err)
  161. }
  162. }
  163. }
  164. }
  165. }
  166. // Adds the base module to the overrides property, if exists, of the overriding module. See the
  167. // comment on OverridableModuleBase.overridesProperty for details.
  168. if b.overridesProperty != nil {
  169. *b.overridesProperty = append(*b.overridesProperty, ctx.ModuleName())
  170. }
  171. b.overridableModuleProperties.OverriddenBy = o.Name()
  172. b.overridableModuleProperties.OverriddenByModuleDir = o.ModuleDir()
  173. if oBazelable, ok := o.base().module.(Bazelable); ok {
  174. if bBazelable, ok := m.(Bazelable); ok {
  175. oProps := oBazelable.bazelProps()
  176. bProps := bBazelable.bazelProps()
  177. bProps.Bazel_module.Bp2build_available = oProps.Bazel_module.Bp2build_available
  178. bProps.Bazel_module.Label = oProps.Bazel_module.Label
  179. } else {
  180. ctx.ModuleErrorf("Override type cannot be Bazelable if original module type is not Bazelable %v %v.", o.Name(), m.Name())
  181. }
  182. }
  183. }
  184. // GetOverriddenBy returns the name of the override module that has overridden this module.
  185. // For example, if an override module foo has its 'base' property set to bar, then another local variant
  186. // of bar is created and its properties are overriden by foo. This method returns bar when called from
  187. // the new local variant. It returns "" when called from the original variant of bar.
  188. func (b *OverridableModuleBase) GetOverriddenBy() string {
  189. return b.overridableModuleProperties.OverriddenBy
  190. }
  191. func (b *OverridableModuleBase) GetOverriddenByModuleDir() string {
  192. return b.overridableModuleProperties.OverriddenByModuleDir
  193. }
  194. func (b *OverridableModuleBase) OverridablePropertiesDepsMutator(ctx BottomUpMutatorContext) {
  195. }
  196. // Mutators for override/overridable modules. All the fun happens in these functions. It is critical
  197. // to keep them in this order and not put any order mutators between them.
  198. func RegisterOverridePostDepsMutators(ctx RegisterMutatorsContext) {
  199. ctx.BottomUp("override_deps", overrideModuleDepsMutator).Parallel()
  200. ctx.BottomUp("perform_override", performOverrideMutator).Parallel()
  201. // overridableModuleDepsMutator calls OverridablePropertiesDepsMutator so that overridable modules can
  202. // add deps from overridable properties.
  203. ctx.BottomUp("overridable_deps", overridableModuleDepsMutator).Parallel()
  204. // Because overridableModuleDepsMutator is run after PrebuiltPostDepsMutator,
  205. // prebuilt's ReplaceDependencies doesn't affect to those deps added by overridable properties.
  206. // By running PrebuiltPostDepsMutator again after overridableModuleDepsMutator, deps via overridable properties
  207. // can be replaced with prebuilts.
  208. ctx.BottomUp("replace_deps_on_prebuilts_for_overridable_deps_again", PrebuiltPostDepsMutator).Parallel()
  209. ctx.BottomUp("replace_deps_on_override", replaceDepsOnOverridingModuleMutator).Parallel()
  210. }
  211. type overrideBaseDependencyTag struct {
  212. blueprint.BaseDependencyTag
  213. }
  214. var overrideBaseDepTag overrideBaseDependencyTag
  215. // Adds dependency on the base module to the overriding module so that they can be visited in the
  216. // next phase.
  217. func overrideModuleDepsMutator(ctx BottomUpMutatorContext) {
  218. if module, ok := ctx.Module().(OverrideModule); ok {
  219. base := String(module.getOverrideModuleProperties().Base)
  220. if !ctx.OtherModuleExists(base) {
  221. ctx.PropertyErrorf("base", "%q is not a valid module name", base)
  222. return
  223. }
  224. // See if there's a prebuilt module that overrides this override module with prefer flag,
  225. // in which case we call HideFromMake on the corresponding variant later.
  226. ctx.VisitDirectDepsWithTag(PrebuiltDepTag, func(dep Module) {
  227. prebuilt := GetEmbeddedPrebuilt(dep)
  228. if prebuilt == nil {
  229. panic("PrebuiltDepTag leads to a non-prebuilt module " + dep.Name())
  230. }
  231. if prebuilt.UsePrebuilt() {
  232. module.setOverriddenByPrebuilt(dep)
  233. return
  234. }
  235. })
  236. baseModule := ctx.AddDependency(ctx.Module(), overrideBaseDepTag, *module.getOverrideModuleProperties().Base)[0]
  237. if o, ok := baseModule.(OverridableModule); ok {
  238. overrideModule := ctx.Module().(OverrideModule)
  239. overrideModule.setModuleDir(ctx.ModuleDir())
  240. o.addOverride(overrideModule)
  241. }
  242. }
  243. }
  244. // Now, goes through all overridable modules, finds all modules overriding them, creates a local
  245. // variant for each of them, and performs the actual overriding operation by calling override().
  246. func performOverrideMutator(ctx BottomUpMutatorContext) {
  247. if b, ok := ctx.Module().(OverridableModule); ok {
  248. overrides := b.getOverrides()
  249. if len(overrides) == 0 {
  250. return
  251. }
  252. variants := make([]string, len(overrides)+1)
  253. // The first variant is for the original, non-overridden, base module.
  254. variants[0] = ""
  255. for i, o := range overrides {
  256. variants[i+1] = o.(Module).Name()
  257. }
  258. mods := ctx.CreateLocalVariations(variants...)
  259. // Make the original variation the default one to depend on if no other override module variant
  260. // is specified.
  261. ctx.AliasVariation(variants[0])
  262. for i, o := range overrides {
  263. mods[i+1].(OverridableModule).override(ctx, mods[i+1], o)
  264. if prebuilt := o.getOverriddenByPrebuilt(); prebuilt != nil {
  265. // The overriding module itself, too, is overridden by a prebuilt.
  266. // Perform the same check for replacement
  267. checkInvariantsForSourceAndPrebuilt(ctx, mods[i+1], prebuilt)
  268. // Copy the flag and hide it in make
  269. mods[i+1].ReplacedByPrebuilt()
  270. }
  271. }
  272. } else if o, ok := ctx.Module().(OverrideModule); ok {
  273. // Create a variant of the overriding module with its own name. This matches the above local
  274. // variant name rule for overridden modules, and thus allows ReplaceDependencies to match the
  275. // two.
  276. ctx.CreateLocalVariations(o.Name())
  277. // To allow dependencies to be added without having to know the above variation.
  278. ctx.AliasVariation(o.Name())
  279. }
  280. }
  281. func overridableModuleDepsMutator(ctx BottomUpMutatorContext) {
  282. if b, ok := ctx.Module().(OverridableModule); ok && b.Enabled() {
  283. b.OverridablePropertiesDepsMutator(ctx)
  284. }
  285. }
  286. func replaceDepsOnOverridingModuleMutator(ctx BottomUpMutatorContext) {
  287. if b, ok := ctx.Module().(OverridableModule); ok {
  288. if o := b.GetOverriddenBy(); o != "" {
  289. // Redirect dependencies on the overriding module to this overridden module. Overriding
  290. // modules are basically pseudo modules, and all build actions are associated to overridden
  291. // modules. Therefore, dependencies on overriding modules need to be forwarded there as well.
  292. ctx.ReplaceDependencies(o)
  293. }
  294. }
  295. }
  296. // ModuleNameWithPossibleOverride returns the name of the OverrideModule that overrides the current
  297. // variant of this OverridableModule, or ctx.ModuleName() if this module is not an OverridableModule
  298. // or if this variant is not overridden.
  299. func ModuleNameWithPossibleOverride(ctx BazelConversionContext) string {
  300. return moduleNameWithPossibleOverride(ctx, ctx.Module())
  301. }
  302. func moduleNameWithPossibleOverride(ctx bazelOtherModuleContext, module blueprint.Module) string {
  303. if overridable, ok := module.(OverridableModule); ok {
  304. if o := overridable.GetOverriddenBy(); o != "" {
  305. return o
  306. }
  307. }
  308. return ctx.OtherModuleName(module)
  309. }
  310. // moduleDirWithPossibleOverride returns the dir of the OverrideModule that overrides the current
  311. // variant of the given OverridableModule, or ctx.OtherModuleName() if the module is not an
  312. // OverridableModule or if the variant is not overridden.
  313. func moduleDirWithPossibleOverride(ctx bazelOtherModuleContext, module blueprint.Module) string {
  314. if overridable, ok := module.(OverridableModule); ok {
  315. if o := overridable.GetOverriddenByModuleDir(); o != "" {
  316. return o
  317. }
  318. }
  319. return ctx.OtherModuleDir(module)
  320. }