Merge "Generate monolithic hidden API files direct from class jars" am: 21f62ef867 am: b28f562092 (8063427d) · Commits · e / os / android_build_soong

apex/apex_test.go

+16 −16

Original line number	Diff line number	Diff line
		@@ -4564,7 +4564,7 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) {
		checkHiddenAPIIndexInputs := func(t testing.T, ctx android.TestContext, expectedInputs string) {
		t.Helper()
		platformBootclasspath := ctx.ModuleForTests("platform-bootclasspath", "android_common")
		indexRule := platformBootclasspath.Rule("platform-bootclasspath-monolithic-hiddenapi-index")
		indexRule := platformBootclasspath.Rule("monolithic_hidden_API_index")
		java.CheckHiddenAPIRuleInputs(t, expectedInputs, indexRule)
		}

		@@ -4602,10 +4602,10 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) {
		checkBootDexJarPath(t, ctx, "libfoo", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libfoo.jar")
		checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")

		// Make sure that the dex file from the prebuilt_apex contributes to the hiddenapi index file.
		// Verify the correct module jars contribute to the hiddenapi index file.
		checkHiddenAPIIndexInputs(t, ctx, `
		.intermediates/libbar/android_common_myapex/hiddenapi/index.csv
		.intermediates/libfoo/android_common_myapex/hiddenapi/index.csv
		.intermediates/libbar.stubs/android_common/combined/libbar.stubs.jar
		.intermediates/libfoo/android_common_myapex/combined/libfoo.jar
		`)
		})

		@@ -4636,10 +4636,10 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) {
		checkBootDexJarPath(t, ctx, "libfoo", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libfoo.jar")
		checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")

		// Make sure that the dex file from the apex_set contributes to the hiddenapi index file.
		// Verify the correct module jars contribute to the hiddenapi index file.
		checkHiddenAPIIndexInputs(t, ctx, `
		.intermediates/libbar/android_common_myapex/hiddenapi/index.csv
		.intermediates/libfoo/android_common_myapex/hiddenapi/index.csv
		.intermediates/libbar.stubs/android_common/combined/libbar.stubs.jar
		.intermediates/libfoo/android_common_myapex/combined/libfoo.jar
		`)
		})

		@@ -4743,10 +4743,10 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) {
		checkBootDexJarPath(t, ctx, "libfoo", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libfoo.jar")
		checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")

		// Make sure that the dex file from the prebuilt_apex contributes to the hiddenapi index file.
		// Verify the correct module jars contribute to the hiddenapi index file.
		checkHiddenAPIIndexInputs(t, ctx, `
		.intermediates/prebuilt_libbar/android_common_myapex/hiddenapi/index.csv
		.intermediates/prebuilt_libfoo/android_common_myapex/hiddenapi/index.csv
		.intermediates/prebuilt_libbar.stubs/android_common/combined/libbar.stubs.jar
		.intermediates/prebuilt_libfoo/android_common_myapex/combined/libfoo.jar
		`)
		})

		@@ -4810,10 +4810,10 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) {
		checkBootDexJarPath(t, ctx, "libfoo", "out/soong/.intermediates/libfoo/android_common_apex10000/hiddenapi/libfoo.jar")
		checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/libbar/android_common_myapex/hiddenapi/libbar.jar")

		// Make sure that the dex file from the prebuilt_apex contributes to the hiddenapi index file.
		// Verify the correct module jars contribute to the hiddenapi index file.
		checkHiddenAPIIndexInputs(t, ctx, `
		.intermediates/libbar/android_common_myapex/hiddenapi/index.csv
		.intermediates/libfoo/android_common_apex10000/hiddenapi/index.csv
		.intermediates/libbar/android_common_myapex/javac/libbar.jar
		.intermediates/libfoo/android_common_apex10000/javac/libfoo.jar
		`)
		})

		@@ -4879,10 +4879,10 @@ func TestBootDexJarsFromSourcesAndPrebuilts(t *testing.T) {
		checkBootDexJarPath(t, ctx, "libfoo", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libfoo.jar")
		checkBootDexJarPath(t, ctx, "libbar", "out/soong/.intermediates/myapex.deapexer/android_common/deapexer/javalib/libbar.jar")

		// Make sure that the dex file from the prebuilt_apex contributes to the hiddenapi index file.
		// Verify the correct module jars contribute to the hiddenapi index file.
		checkHiddenAPIIndexInputs(t, ctx, `
		.intermediates/prebuilt_libbar/android_common_myapex/hiddenapi/index.csv
		.intermediates/prebuilt_libfoo/android_common_myapex/hiddenapi/index.csv
		.intermediates/prebuilt_libbar.stubs/android_common/combined/libbar.stubs.jar
		.intermediates/prebuilt_libfoo/android_common_myapex/combined/libfoo.jar
		`)
		})
		}

java/bootclasspath_fragment.go

+6 −4

Original line number	Diff line number	Diff line
		@@ -129,7 +129,7 @@ type commonBootclasspathFragment interface {
		// produceHiddenAPIAllFlagsFile produces the all-flags.csv and intermediate files.
		//
		// Updates the supplied flagFileInfo with the paths to the generated files set.
		produceHiddenAPIAllFlagsFile(ctx android.ModuleContext, contents []android.Module, stubJarsByKind map[android.SdkKind]android.Paths, flagFileInfo *hiddenAPIFlagFileInfo)
		produceHiddenAPIAllFlagsFile(ctx android.ModuleContext, contents []hiddenAPIModule, stubJarsByKind map[android.SdkKind]android.Paths, flagFileInfo *hiddenAPIFlagFileInfo)
		}

		func bootclasspathFragmentFactory() android.Module {
		@@ -461,9 +461,11 @@ func (b *BootclasspathFragmentModule) generateHiddenAPIBuildActions(ctx android.
		// Resolve the properties to paths.
		flagFileInfo := b.properties.Hidden_api.hiddenAPIFlagFileInfo(ctx)

		hiddenAPIModules := gatherHiddenAPIModuleFromContents(ctx, contents)

		// Delegate the production of the hidden API all flags file to a module type specific method.
		common := ctx.Module().(commonBootclasspathFragment)
		common.produceHiddenAPIAllFlagsFile(ctx, contents, stubJarsByKind, &flagFileInfo)
		common.produceHiddenAPIAllFlagsFile(ctx, hiddenAPIModules, stubJarsByKind, &flagFileInfo)

		// Store the information for use by platform_bootclasspath.
		ctx.SetProvider(hiddenAPIFlagFileInfoProvider, flagFileInfo)
		@@ -471,7 +473,7 @@ func (b *BootclasspathFragmentModule) generateHiddenAPIBuildActions(ctx android.

		// produceHiddenAPIAllFlagsFile produces the hidden API all-flags.csv file (and supporting files)
		// for the fragment.
		func (b BootclasspathFragmentModule) produceHiddenAPIAllFlagsFile(ctx android.ModuleContext, contents []android.Module, stubJarsByKind map[android.SdkKind]android.Paths, flagFileInfo hiddenAPIFlagFileInfo) {
		func (b BootclasspathFragmentModule) produceHiddenAPIAllFlagsFile(ctx android.ModuleContext, contents []hiddenAPIModule, stubJarsByKind map[android.SdkKind]android.Paths, flagFileInfo hiddenAPIFlagFileInfo) {
		// If no stubs have been provided then don't perform hidden API processing. This is a temporary
		// workaround to avoid existing bootclasspath_fragments that do not provide stubs breaking the
		// build.
		@@ -718,7 +720,7 @@ func (module *prebuiltBootclasspathFragmentModule) Name() string {

		// produceHiddenAPIAllFlagsFile returns a path to the prebuilt all-flags.csv or nil if none is
		// specified.
		func (module prebuiltBootclasspathFragmentModule) produceHiddenAPIAllFlagsFile(ctx android.ModuleContext, _ []android.Module, _ map[android.SdkKind]android.Paths, flagFileInfo hiddenAPIFlagFileInfo) {
		func (module prebuiltBootclasspathFragmentModule) produceHiddenAPIAllFlagsFile(ctx android.ModuleContext, contents []hiddenAPIModule, stubJarsByKind map[android.SdkKind]android.Paths, flagFileInfo hiddenAPIFlagFileInfo) {
		pathsForOptionalSrc := func(src *string) android.Paths {
		if src == nil {
		// TODO(b/179354495): Fail if this is not provided once prebuilts have been updated.

java/hiddenapi.go

+7 −15

Original line number	Diff line number	Diff line
		@@ -91,31 +91,22 @@ type hiddenAPI struct {
		classesJarPaths android.Paths
		}

		func (h *hiddenAPI) flagsCSV() android.Path {
		return h.flagsCSVPath
		}

		func (h *hiddenAPI) metadataCSV() android.Path {
		return h.metadataCSVPath
		}

		func (h *hiddenAPI) bootDexJar() android.Path {
		return h.bootDexJarPath
		}

		func (h *hiddenAPI) indexCSV() android.Path {
		return h.indexCSVPath
		}

		func (h *hiddenAPI) classesJars() android.Paths {
		return h.classesJarPaths
		}

		// hiddenAPIModule is the interface a module that embeds the hiddenAPI structure must implement.
		type hiddenAPIModule interface {
		android.Module
		hiddenAPIIntf
		}

		type hiddenAPIIntf interface {
		bootDexJar() android.Path
		flagsCSV() android.Path
		indexCSV() android.Path
		metadataCSV() android.Path
		classesJars() android.Paths
		}

		@@ -312,6 +303,7 @@ func buildRuleToGenerateIndex(ctx android.ModuleContext, desc string, classesJar
		BuiltTool("merge_csv").
		Flag("--zip_input").
		Flag("--key_field signature").
		FlagWithArg("--header=", "signature,file,startline,startcol,endline,endcol,properties").
		FlagWithOutput("--output=", indexCSV).
		Inputs(classesJars)
		rule.Build(desc, desc)

java/hiddenapi_modular.go

+51 −26

Original line number	Diff line number	Diff line
		@@ -422,12 +422,12 @@ func pathForValidation(ctx android.PathContext, path android.WritablePath) andro
		// an entry for every single member in the dex implementation jars of the individual modules. Every
		// signature in any of the other files MUST be included in this file.
		//
		// moduleSpecificFlagsPaths are the paths to the flags files generated by each module using
		// information from the baseFlagsPath as well as from annotations within the source.
		// annotationFlags is the path to the annotation flags file generated from annotation information
		// in each module.
		//
		// augmentationInfo is a struct containing paths to files that augment the information provided by
		// the moduleSpecificFlagsPaths.
		func buildRuleToGenerateHiddenApiFlags(ctx android.BuilderContext, name, desc string, outputPath android.WritablePath, baseFlagsPath android.Path, moduleSpecificFlagsPaths android.Paths, flagFileInfo *hiddenAPIFlagFileInfo) {
		// flagFileInfo is a struct containing paths to files that augment the information provided by
		// the annotationFlags.
		func buildRuleToGenerateHiddenApiFlags(ctx android.BuilderContext, name, desc string, outputPath android.WritablePath, baseFlagsPath android.Path, annotationFlags android.Path, flagFileInfo *hiddenAPIFlagFileInfo) {

		// The file which is used to record that the flags file is valid.
		var validFile android.WritablePath
		@@ -457,7 +457,7 @@ func buildRuleToGenerateHiddenApiFlags(ctx android.BuilderContext, name, desc st
		command := rule.Command().
		BuiltTool("generate_hiddenapi_lists").
		FlagWithInput("--csv ", baseFlagsPath).
		Inputs(moduleSpecificFlagsPaths).
		Input(annotationFlags).
		FlagWithOutput("--output ", tempPath)

		// Add the options for the different categories of flag files.
		@@ -495,31 +495,18 @@ func buildRuleToGenerateHiddenApiFlags(ctx android.BuilderContext, name, desc st
		// * metadata.csv
		// * index.csv
		// * all-flags.csv
		func hiddenAPIGenerateAllFlagsForBootclasspathFragment(ctx android.ModuleContext, contents []android.Module, stubJarsByKind map[android.SdkKind]android.Paths, flagFileInfo *hiddenAPIFlagFileInfo) {

		func hiddenAPIGenerateAllFlagsForBootclasspathFragment(ctx android.ModuleContext, contents []hiddenAPIModule, stubJarsByKind map[android.SdkKind]android.Paths, flagFileInfo *hiddenAPIFlagFileInfo) {
		hiddenApiSubDir := "modular-hiddenapi"

		bootDexJars := android.Paths{}
		classesJars := android.Paths{}
		for _, module := range contents {
		if hiddenAPI, ok := module.(hiddenAPIIntf); ok {
		classesJars = append(classesJars, hiddenAPI.classesJars()...)
		bootDexJar := hiddenAPI.bootDexJar()
		if bootDexJar == nil {
		ctx.ModuleErrorf("module %s does not provide a dex jar", module)
		} else {
		bootDexJars = append(bootDexJars, bootDexJar)
		}
		} else {
		ctx.ModuleErrorf("module %s does not implement hiddenAPIIntf", module)
		}
		}

		// Generate the stub-flags.csv.
		bootDexJars := extractBootDexJarsFromHiddenAPIModules(ctx, contents)
		stubFlagsCSV := android.PathForModuleOut(ctx, hiddenApiSubDir, "stub-flags.csv")
		rule := ruleToGenerateHiddenAPIStubFlagsFile(ctx, stubFlagsCSV, bootDexJars, stubJarsByKind)
		rule.Build("modularHiddenAPIStubFlagsFile", "modular hiddenapi stub flags")

		// Extract the classes jars from the contents.
		classesJars := extractClassJarsFromHiddenAPIModules(ctx, contents)

		// Generate the set of flags from the annotations in the source code.
		annotationFlagsCSV := android.PathForModuleOut(ctx, hiddenApiSubDir, "annotation-flags.csv")
		buildRuleToGenerateAnnotationFlags(ctx, "modular hiddenapi annotation flags", classesJars, stubFlagsCSV, annotationFlagsCSV)
		@@ -528,7 +515,7 @@ func hiddenAPIGenerateAllFlagsForBootclasspathFragment(ctx android.ModuleContext
		metadataCSV := android.PathForModuleOut(ctx, hiddenApiSubDir, "metadata.csv")
		buildRuleToGenerateMetadata(ctx, "modular hiddenapi metadata", classesJars, stubFlagsCSV, metadataCSV)

		// Generate the index file from the annotations in the source code.
		// Generate the index file from the CSV files in the classes jars.
		indexCSV := android.PathForModuleOut(ctx, hiddenApiSubDir, "index.csv")
		buildRuleToGenerateIndex(ctx, "modular hiddenapi index", classesJars, indexCSV)

		@@ -542,7 +529,7 @@ func hiddenAPIGenerateAllFlagsForBootclasspathFragment(ctx android.ModuleContext
		// Generate the all-flags.csv which are the flags that will, in future, be encoded into the dex
		// files.
		outputPath := android.PathForModuleOut(ctx, hiddenApiSubDir, "all-flags.csv")
		buildRuleToGenerateHiddenApiFlags(ctx, "modularHiddenApiAllFlags", "modular hiddenapi all flags", outputPath, stubFlagsCSV, android.Paths{annotationFlagsCSV}, flagFileInfo)
		buildRuleToGenerateHiddenApiFlags(ctx, "modularHiddenApiAllFlags", "modular hiddenapi all flags", outputPath, stubFlagsCSV, annotationFlagsCSV, flagFileInfo)

		// Store the paths in the info for use by other modules and sdk snapshot generation.
		flagFileInfo.StubFlagsPaths = android.Paths{stubFlagsCSV}
		@@ -551,3 +538,41 @@ func hiddenAPIGenerateAllFlagsForBootclasspathFragment(ctx android.ModuleContext
		flagFileInfo.IndexPaths = android.Paths{indexCSV}
		flagFileInfo.AllFlagsPaths = android.Paths{outputPath}
		}

		// gatherHiddenAPIModuleFromContents gathers the hiddenAPIModule from the supplied contents.
		func gatherHiddenAPIModuleFromContents(ctx android.ModuleContext, contents []android.Module) []hiddenAPIModule {
		hiddenAPIModules := []hiddenAPIModule{}
		for _, module := range contents {
		if hiddenAPI, ok := module.(hiddenAPIModule); ok {
		hiddenAPIModules = append(hiddenAPIModules, hiddenAPI)
		} else if _, ok := module.(*DexImport); ok {
		// Ignore this for the purposes of hidden API processing
		} else {
		ctx.ModuleErrorf("module %s does not implement hiddenAPIModule", module)
		}
		}
		return hiddenAPIModules
		}

		// extractBootDexJarsFromHiddenAPIModules extracts the boot dex jars from the supplied modules.
		func extractBootDexJarsFromHiddenAPIModules(ctx android.ModuleContext, contents []hiddenAPIModule) android.Paths {
		bootDexJars := android.Paths{}
		for _, module := range contents {
		bootDexJar := module.bootDexJar()
		if bootDexJar == nil {
		ctx.ModuleErrorf("module %s does not provide a dex jar", module)
		} else {
		bootDexJars = append(bootDexJars, bootDexJar)
		}
		}
		return bootDexJars
		}

		// extractClassJarsFromHiddenAPIModules extracts the class jars from the supplied modules.
		func extractClassJarsFromHiddenAPIModules(ctx android.ModuleContext, contents []hiddenAPIModule) android.Paths {
		classesJars := android.Paths{}
		for _, module := range contents {
		classesJars = append(classesJars, module.classesJars()...)
		}
		return classesJars
		}

java/platform_bootclasspath.go

+32 −112

Original line number	Diff line number	Diff line
		@@ -257,17 +257,6 @@ func (b *platformBootclasspathModule) getImageConfig(ctx android.EarlyModuleCont
		return defaultBootImageConfig(ctx)
		}

		// hiddenAPISupportingModule encapsulates the information provided by any module that contributes to
		// the hidden API processing.
		type hiddenAPISupportingModule struct {
		module android.Module

		bootDexJar android.Path
		flagsCSV android.Path
		indexCSV android.Path
		metadataCSV android.Path
		}

		// generateHiddenAPIBuildActions generates all the hidden API related build rules.
		func (b *platformBootclasspathModule) generateHiddenAPIBuildActions(ctx android.ModuleContext, modules []android.Module, fragments []android.Module) {

		@@ -290,67 +279,6 @@ func (b *platformBootclasspathModule) generateHiddenAPIBuildActions(ctx android.
		return
		}

		// nilPathHandler will check the supplied path and if it is nil then it will either immediately
		// report an error, or it will defer the error reporting until it is actually used, depending
		// whether missing dependencies are allowed.
		var nilPathHandler func(path android.Path, name string, module android.Module) android.Path
		if ctx.Config().AllowMissingDependencies() {
		nilPathHandler = func(path android.Path, name string, module android.Module) android.Path {
		if path == nil {
		outputPath := android.PathForModuleOut(ctx, "missing", module.Name(), name)
		path = outputPath

		// Create an error rule that pretends to create the output file but will actually fail if it
		// is run.
		ctx.Build(pctx, android.BuildParams{
		Rule: android.ErrorRule,
		Output: outputPath,
		Args: map[string]string{
		"error": fmt.Sprintf("missing hidden API file: %s for %s", name, module),
		},
		})
		}
		return path
		}
		} else {
		nilPathHandler = func(path android.Path, name string, module android.Module) android.Path {
		if path == nil {
		ctx.ModuleErrorf("module %s does not provide a %s file", module, name)
		}
		return path
		}
		}

		hiddenAPISupportingModules := []hiddenAPISupportingModule{}
		for _, module := range modules {
		if h, ok := module.(hiddenAPIIntf); ok {
		hiddenAPISupportingModule := hiddenAPISupportingModule{
		module: module,
		bootDexJar: nilPathHandler(h.bootDexJar(), "bootDexJar", module),
		flagsCSV: nilPathHandler(h.flagsCSV(), "flagsCSV", module),
		indexCSV: nilPathHandler(h.indexCSV(), "indexCSV", module),
		metadataCSV: nilPathHandler(h.metadataCSV(), "metadataCSV", module),
		}

		// If any errors were reported when trying to populate the hiddenAPISupportingModule struct
		// then don't add it to the list.
		if ctx.Failed() {
		continue
		}

		hiddenAPISupportingModules = append(hiddenAPISupportingModules, hiddenAPISupportingModule)
		} else if _, ok := module.(*DexImport); ok {
		// Ignore this for the purposes of hidden API processing
		} else {
		ctx.ModuleErrorf("module %s of type %s does not support hidden API processing", module, ctx.OtherModuleType(module))
		}
		}

		moduleSpecificFlagsPaths := android.Paths{}
		for _, module := range hiddenAPISupportingModules {
		moduleSpecificFlagsPaths = append(moduleSpecificFlagsPaths, module.flagsCSV)
		}

		flagFileInfo := b.properties.Hidden_api.hiddenAPIFlagFileInfo(ctx)
		for _, fragment := range fragments {
		if ctx.OtherModuleHasProvider(fragment, hiddenAPIFlagFileInfoProvider) {
		@@ -362,61 +290,53 @@ func (b *platformBootclasspathModule) generateHiddenAPIBuildActions(ctx android.
		// Store the information for testing.
		ctx.SetProvider(hiddenAPIFlagFileInfoProvider, flagFileInfo)

		outputPath := hiddenAPISingletonPaths(ctx).flags
		baseFlagsPath := hiddenAPISingletonPaths(ctx).stubFlags
		buildRuleToGenerateHiddenApiFlags(ctx, "hiddenAPIFlagsFile", "hiddenapi flags", outputPath, baseFlagsPath, moduleSpecificFlagsPaths, &flagFileInfo)

		b.generateHiddenAPIStubFlagsRules(ctx, hiddenAPISupportingModules)
		b.generateHiddenAPIIndexRules(ctx, hiddenAPISupportingModules)
		b.generatedHiddenAPIMetadataRules(ctx, hiddenAPISupportingModules)
		}

		func (b *platformBootclasspathModule) generateHiddenAPIStubFlagsRules(ctx android.ModuleContext, modules []hiddenAPISupportingModule) {
		bootDexJars := android.Paths{}
		for _, module := range modules {
		bootDexJars = append(bootDexJars, module.bootDexJar)
		}
		hiddenAPIModules := gatherHiddenAPIModuleFromContents(ctx, modules)

		sdkKindToStubPaths := hiddenAPIGatherStubLibDexJarPaths(ctx, nil)

		outputPath := hiddenAPISingletonPaths(ctx).stubFlags
		rule := ruleToGenerateHiddenAPIStubFlagsFile(ctx, outputPath, bootDexJars, sdkKindToStubPaths)
		// Generate the monolithic stub-flags.csv file.
		bootDexJars := extractBootDexJarsFromHiddenAPIModules(ctx, hiddenAPIModules)
		stubFlags := hiddenAPISingletonPaths(ctx).stubFlags
		rule := ruleToGenerateHiddenAPIStubFlagsFile(ctx, stubFlags, bootDexJars, sdkKindToStubPaths)
		rule.Build("platform-bootclasspath-monolithic-hiddenapi-stub-flags", "monolithic hidden API stub flags")
		}

		func (b *platformBootclasspathModule) generateHiddenAPIIndexRules(ctx android.ModuleContext, modules []hiddenAPISupportingModule) {
		indexes := android.Paths{}
		for _, module := range modules {
		indexes = append(indexes, module.indexCSV)
		}
		// Extract the classes jars from the contents.
		classesJars := extractClassJarsFromHiddenAPIModules(ctx, hiddenAPIModules)

		rule := android.NewRuleBuilder(pctx, ctx)
		rule.Command().
		BuiltTool("merge_csv").
		Flag("--key_field signature").
		FlagWithArg("--header=", "signature,file,startline,startcol,endline,endcol,properties").
		FlagWithOutput("--output=", hiddenAPISingletonPaths(ctx).index).
		Inputs(indexes)
		rule.Build("platform-bootclasspath-monolithic-hiddenapi-index", "monolithic hidden API index")
		}
		// Generate the annotation-flags.csv file from all the module annotations.
		annotationFlags := android.PathForModuleOut(ctx, "hiddenapi-monolithic", "annotation-flags.csv")
		buildRuleToGenerateAnnotationFlags(ctx, "monolithic hiddenapi flags", classesJars, stubFlags, annotationFlags)

		func (b *platformBootclasspathModule) generatedHiddenAPIMetadataRules(ctx android.ModuleContext, modules []hiddenAPISupportingModule) {
		metadataCSVFiles := android.Paths{}
		for _, module := range modules {
		metadataCSVFiles = append(metadataCSVFiles, module.metadataCSV)
		}
		// Generate the monotlithic hiddenapi-flags.csv file.
		allFlags := hiddenAPISingletonPaths(ctx).flags
		buildRuleToGenerateHiddenApiFlags(ctx, "hiddenAPIFlagsFile", "hiddenapi flags", allFlags, stubFlags, annotationFlags, &flagFileInfo)

		rule := android.NewRuleBuilder(pctx, ctx)
		// Generate an intermediate monolithic hiddenapi-metadata.csv file directly from the annotations
		// in the source code.
		intermediateMetadataCSV := android.PathForModuleOut(ctx, "hiddenapi-monolithic", "intermediate-metadata.csv")
		buildRuleToGenerateMetadata(ctx, "monolithic hidden API metadata", classesJars, stubFlags, intermediateMetadataCSV)

		outputPath := hiddenAPISingletonPaths(ctx).metadata
		// Reformat the intermediate file to add \| quotes just in case that is important for the tools
		// that consume the metadata file.
		// TODO(b/179354495): Investigate whether it is possible to remove this reformatting step.
		metadataCSV := hiddenAPISingletonPaths(ctx).metadata
		b.buildRuleMergeCSV(ctx, "reformat monolithic hidden API metadata", android.Paths{intermediateMetadataCSV}, metadataCSV)

		// Generate the monolithic hiddenapi-index.csv file directly from the CSV files in the classes
		// jars.
		indexCSV := hiddenAPISingletonPaths(ctx).index
		buildRuleToGenerateIndex(ctx, "monolithic hidden API index", classesJars, indexCSV)
		}

		func (b *platformBootclasspathModule) buildRuleMergeCSV(ctx android.ModuleContext, desc string, inputPaths android.Paths, outputPath android.WritablePath) {
		rule := android.NewRuleBuilder(pctx, ctx)
		rule.Command().
		BuiltTool("merge_csv").
		Flag("--key_field signature").
		FlagWithOutput("--output=", outputPath).
		Inputs(metadataCSVFiles)
		Inputs(inputPaths)

		rule.Build("platform-bootclasspath-monolithic-hiddenapi-metadata", "monolithic hidden API metadata")
		rule.Build(desc, desc)
		}

		// generateHiddenApiMakeVars generates make variables needed by hidden API related make rules, e.g.