1// Copyright 2017 Google Inc. All rights reserved. 2// Licensed under the Apache License, Version 2.0 (the "License"); 3// you may not use this file except in compliance with the License. 4// You may obtain a copy of the License at 5// 6// http://www.apache.org/licenses/LICENSE-2.0 7// 8// Unless required by applicable law or agreed to in writing, software 9// distributed under the License is distributed on an "AS IS" BASIS, 10// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11// See the License for the specific language governing permissions and 12// limitations under the License. 13 14package java 15 16import ( 17 "fmt" 18 "io" 19 "strings" 20 21 "github.com/google/blueprint" 22 "github.com/google/blueprint/depset" 23 "github.com/google/blueprint/proptools" 24 25 "android/soong/android" 26) 27 28// OpenJDK 9 introduces the concept of "system modules", which replace the bootclasspath. This 29// file will produce the rules necessary to convert each unique set of bootclasspath jars into 30// system modules in a runtime image using the jmod and jlink tools. 31 32func init() { 33 RegisterSystemModulesBuildComponents(android.InitRegistrationContext) 34 35 pctx.SourcePathVariable("moduleInfoJavaPath", "build/soong/scripts/jars-to-module-info-java.sh") 36 37 // Register sdk member types. 38 android.RegisterSdkMemberType(&systemModulesSdkMemberType{ 39 android.SdkMemberTypeBase{ 40 PropertyName: "java_system_modules", 41 SupportsSdk: true, 42 }, 43 }) 44} 45 46func RegisterSystemModulesBuildComponents(ctx android.RegistrationContext) { 47 ctx.RegisterModuleType("java_system_modules", SystemModulesFactory) 48 ctx.RegisterModuleType("java_system_modules_import", systemModulesImportFactory) 49} 50 51var ( 52 jarsTosystemModules = pctx.AndroidStaticRule("jarsTosystemModules", blueprint.RuleParams{ 53 Command: `rm -rf ${outDir} ${workDir} && mkdir -p ${workDir}/jmod && ` + 54 `${moduleInfoJavaPath} java.base $in > ${workDir}/module-info.java && ` + 55 `${config.JavacCmd} --system=none --patch-module=java.base=${classpath} ${workDir}/module-info.java && ` + 56 `${config.SoongZipCmd} -jar -o ${workDir}/classes.jar -C ${workDir} -f ${workDir}/module-info.class && ` + 57 `${config.MergeZipsCmd} -j ${workDir}/module.jar ${workDir}/classes.jar $in && ` + 58 // Note: The version of the java.base module created must match the version 59 // of the jlink tool which consumes it. 60 // Use LINUX-OTHER to be compatible with JDK 21+ (b/294137077) 61 `${config.JmodCmd} create --module-version ${config.JlinkVersion} --target-platform LINUX-OTHER ` + 62 ` --class-path ${workDir}/module.jar ${workDir}/jmod/java.base.jmod && ` + 63 `${config.JlinkCmd} --module-path ${workDir}/jmod --add-modules java.base --output ${outDir} ` + 64 // Note: The system-modules jlink plugin is disabled because (a) it is not 65 // useful on Android, and (b) it causes errors with later versions of jlink 66 // when the jdk.internal.module is absent from java.base (as it is here). 67 ` --disable-plugin system-modules && ` + 68 `rm -rf ${workDir} && ` + 69 `cp ${config.JrtFsJar} ${outDir}/lib/`, 70 CommandDeps: []string{ 71 "${moduleInfoJavaPath}", 72 "${config.JavacCmd}", 73 "${config.SoongZipCmd}", 74 "${config.MergeZipsCmd}", 75 "${config.JmodCmd}", 76 "${config.JlinkCmd}", 77 "${config.JrtFsJar}", 78 }, 79 }, 80 "classpath", "outDir", "workDir") 81 82 // Dependency tag that causes the added dependencies to be added as java_header_libs 83 // to the sdk/module_exports/snapshot. Dependencies that are added automatically via this tag are 84 // not automatically exported. 85 systemModulesLibsTag = android.DependencyTagForSdkMemberType(javaHeaderLibsSdkMemberType, false) 86) 87 88func TransformJarsToSystemModules(ctx android.ModuleContext, jars android.Paths) (android.Path, android.Paths) { 89 outDir := android.PathForModuleOut(ctx, "system") 90 workDir := android.PathForModuleOut(ctx, "modules") 91 outputFile := android.PathForModuleOut(ctx, "system/lib/modules") 92 outputs := android.WritablePaths{ 93 outputFile, 94 android.PathForModuleOut(ctx, "system/lib/jrt-fs.jar"), 95 android.PathForModuleOut(ctx, "system/release"), 96 } 97 98 ctx.Build(pctx, android.BuildParams{ 99 Rule: jarsTosystemModules, 100 Description: "system modules", 101 Outputs: outputs, 102 Inputs: jars, 103 Args: map[string]string{ 104 "classpath": strings.Join(jars.Strings(), ":"), 105 "workDir": workDir.String(), 106 "outDir": outDir.String(), 107 }, 108 }) 109 110 return outDir, outputs.Paths() 111} 112 113// java_system_modules creates a system module from a set of java libraries that can 114// be referenced from the system_modules property. It must contain at a minimum the 115// java.base module which must include classes from java.lang amongst other java packages. 116func SystemModulesFactory() android.Module { 117 module := &SystemModules{} 118 module.AddProperties(&module.properties) 119 android.InitAndroidArchModule(module, android.HostAndDeviceSupported, android.MultilibCommon) 120 android.InitDefaultableModule(module) 121 return module 122} 123 124type SystemModulesProviderInfo struct { 125 // The aggregated header jars from all jars specified in the libs property. 126 // Used when system module is added as a dependency to bootclasspath. 127 HeaderJars android.Paths 128 129 OutputDir android.Path 130 OutputDirDeps android.Paths 131 132 // depset of header jars for this module and all transitive static dependencies 133 TransitiveStaticLibsHeaderJars depset.DepSet[android.Path] 134} 135 136var SystemModulesProvider = blueprint.NewProvider[*SystemModulesProviderInfo]() 137 138type SystemModules struct { 139 android.ModuleBase 140 android.DefaultableModuleBase 141 142 properties SystemModulesProperties 143 144 outputDir android.Path 145 outputDeps android.Paths 146} 147 148type SystemModulesProperties struct { 149 // List of java library modules that should be included in the system modules 150 Libs []string 151} 152 153func (system *SystemModules) GenerateAndroidBuildActions(ctx android.ModuleContext) { 154 var jars android.Paths 155 156 var transitiveStaticLibsHeaderJars []depset.DepSet[android.Path] 157 ctx.VisitDirectDepsWithTag(systemModulesLibsTag, func(module android.Module) { 158 if dep, ok := android.OtherModuleProvider(ctx, module, JavaInfoProvider); ok { 159 jars = append(jars, dep.HeaderJars...) 160 transitiveStaticLibsHeaderJars = append(transitiveStaticLibsHeaderJars, dep.TransitiveStaticLibsHeaderJars) 161 } 162 }) 163 164 system.outputDir, system.outputDeps = TransformJarsToSystemModules(ctx, jars) 165 166 android.SetProvider(ctx, SystemModulesProvider, &SystemModulesProviderInfo{ 167 HeaderJars: jars, 168 OutputDir: system.outputDir, 169 OutputDirDeps: system.outputDeps, 170 TransitiveStaticLibsHeaderJars: depset.New(depset.PREORDER, nil, transitiveStaticLibsHeaderJars), 171 }) 172} 173 174// ComponentDepsMutator is called before prebuilt modules without a corresponding source module are 175// renamed so unless the supplied libs specifically includes the prebuilt_ prefix this is guaranteed 176// to only add dependencies on source modules. 177// 178// The systemModuleLibsTag will prevent the prebuilt mutators from replacing this dependency so it 179// will never be changed to depend on a prebuilt either. 180func (system *SystemModules) ComponentDepsMutator(ctx android.BottomUpMutatorContext) { 181 ctx.AddVariationDependencies(nil, systemModulesLibsTag, system.properties.Libs...) 182} 183 184func (system *SystemModules) AndroidMk() android.AndroidMkData { 185 return android.AndroidMkData{ 186 Custom: func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) { 187 fmt.Fprintln(w) 188 189 makevar := "SOONG_SYSTEM_MODULES_" + name 190 fmt.Fprintln(w, makevar, ":=$=", system.outputDir.String()) 191 fmt.Fprintln(w) 192 193 makevar = "SOONG_SYSTEM_MODULES_LIBS_" + name 194 fmt.Fprintln(w, makevar, ":=$=", strings.Join(system.properties.Libs, " ")) 195 fmt.Fprintln(w) 196 197 makevar = "SOONG_SYSTEM_MODULES_DEPS_" + name 198 fmt.Fprintln(w, makevar, ":=$=", strings.Join(system.outputDeps.Strings(), " ")) 199 fmt.Fprintln(w) 200 201 fmt.Fprintln(w, name+":", "$("+makevar+")") 202 fmt.Fprintln(w, ".PHONY:", name) 203 // TODO(b/151177513): Licenses: Doesn't go through base_rules. May have to generate meta_lic and meta_module here. 204 }, 205 } 206} 207 208// A prebuilt version of java_system_modules. It does not import the 209// generated system module, it generates the system module from imported 210// java libraries in the same way that java_system_modules does. It just 211// acts as a prebuilt, i.e. can have the same base name as another module 212// type and the one to use is selected at runtime. 213func systemModulesImportFactory() android.Module { 214 module := &systemModulesImport{} 215 module.AddProperties(&module.properties, &module.prebuiltProperties) 216 android.InitPrebuiltModule(module, &module.properties.Libs) 217 android.InitAndroidArchModule(module, android.HostAndDeviceSupported, android.MultilibCommon) 218 android.InitDefaultableModule(module) 219 return module 220} 221 222type systemModulesImport struct { 223 SystemModules 224 prebuilt android.Prebuilt 225 prebuiltProperties prebuiltSystemModulesProperties 226} 227 228type prebuiltSystemModulesProperties struct { 229 // Name of the source soong module that gets shadowed by this prebuilt 230 // If unspecified, follows the naming convention that the source module of 231 // the prebuilt is Name() without "prebuilt_" prefix 232 Source_module_name *string 233} 234 235func (system *systemModulesImport) Name() string { 236 return system.prebuilt.Name(system.ModuleBase.Name()) 237} 238 239// BaseModuleName returns the source module that will get shadowed by this prebuilt 240// e.g. 241// 242// java_system_modules_import { 243// name: "my_system_modules.v1", 244// source_module_name: "my_system_modules", 245// } 246// 247// java_system_modules_import { 248// name: "my_system_modules.v2", 249// source_module_name: "my_system_modules", 250// } 251// 252// `BaseModuleName` for both will return `my_system_modules` 253func (system *systemModulesImport) BaseModuleName() string { 254 return proptools.StringDefault(system.prebuiltProperties.Source_module_name, system.ModuleBase.Name()) 255} 256 257func (system *systemModulesImport) Prebuilt() *android.Prebuilt { 258 return &system.prebuilt 259} 260 261// ComponentDepsMutator is called before prebuilt modules without a corresponding source module are 262// renamed so as this adds a prebuilt_ prefix this is guaranteed to only add dependencies on source 263// modules. 264func (system *systemModulesImport) ComponentDepsMutator(ctx android.BottomUpMutatorContext) { 265 for _, lib := range system.properties.Libs { 266 ctx.AddVariationDependencies(nil, systemModulesLibsTag, android.PrebuiltNameFromSource(lib)) 267 } 268} 269 270type systemModulesSdkMemberType struct { 271 android.SdkMemberTypeBase 272} 273 274func (mt *systemModulesSdkMemberType) AddDependencies(ctx android.SdkDependencyContext, dependencyTag blueprint.DependencyTag, names []string) { 275 ctx.AddVariationDependencies(nil, dependencyTag, names...) 276} 277 278func (mt *systemModulesSdkMemberType) IsInstance(module android.Module) bool { 279 if _, ok := module.(*SystemModules); ok { 280 // A prebuilt system module cannot be added as a member of an sdk because the source and 281 // snapshot instances would conflict. 282 _, ok := module.(*systemModulesImport) 283 return !ok 284 } 285 return false 286} 287 288func (mt *systemModulesSdkMemberType) AddPrebuiltModule(ctx android.SdkMemberContext, member android.SdkMember) android.BpModule { 289 return ctx.SnapshotBuilder().AddPrebuiltModule(member, "java_system_modules_import") 290} 291 292type systemModulesInfoProperties struct { 293 android.SdkMemberPropertiesBase 294 295 Libs []string 296} 297 298func (mt *systemModulesSdkMemberType) CreateVariantPropertiesStruct() android.SdkMemberProperties { 299 return &systemModulesInfoProperties{} 300} 301 302func (p *systemModulesInfoProperties) PopulateFromVariant(ctx android.SdkMemberContext, variant android.Module) { 303 systemModule := variant.(*SystemModules) 304 p.Libs = systemModule.properties.Libs 305} 306 307func (p *systemModulesInfoProperties) AddToPropertySet(ctx android.SdkMemberContext, propertySet android.BpPropertySet) { 308 if len(p.Libs) > 0 { 309 // Add the references to the libraries that form the system module. 310 propertySet.AddPropertyWithTag("libs", p.Libs, ctx.SnapshotBuilder().SdkMemberReferencePropertyTag(true)) 311 } 312} 313 314// implement the following interface for IDE completion. 315var _ android.IDEInfo = (*SystemModules)(nil) 316 317func (s *SystemModules) IDEInfo(ctx android.BaseModuleContext, ideInfo *android.IdeInfo) { 318 ideInfo.Deps = append(ideInfo.Deps, s.properties.Libs...) 319 ideInfo.Libs = append(ideInfo.Libs, s.properties.Libs...) 320} 321