Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit bdb7495f authored by Kiyoung Kim's avatar Kiyoung Kim
Browse files

Remove unused module definitions in library stub 

There are some module definitions which are implemented for the proof of
concept, but these modules are not in use now. This change removes
unused module definitions to reduce confusion.

Bug: N/A
Test: m nothing passed
Change-Id: I9b8efbc368436eaef66a4e6557006e87c0c27713
parent 76e39981

cc/library_stub.go

+0 −137
Original line number Diff line number Diff line
@@ -26,10 +26,6 @@ func init() { 
func RegisterLibraryStubBuildComponents(ctx android.RegistrationContext) {

	ctx.RegisterModuleType("cc_api_library", CcApiLibraryFactory)

	ctx.RegisterModuleType("cc_api_headers", CcApiHeadersFactory)



	// cc_api_stub_library shares a lot of ndk_library, and this will be refactored later

	ctx.RegisterModuleType("cc_api_stub_library", CcApiStubLibraryFactory)

	ctx.RegisterModuleType("cc_api_contribution", CcApiContributionFactory)

}



// 'cc_api_library' is a module type which is from the exported API surface
@@ -169,136 +165,3 @@ func (d *apiHeadersDecorator) availableFor(what string) bool { 
	// Stub from API surface should be available for any APEX.

	return true

}
 


func CcApiStubLibraryFactory() android.Module {

	module, decorator := NewLibrary(android.DeviceSupported)

	apiStubDecorator := &apiStubDecorator{

		libraryDecorator: decorator,

	}

	apiStubDecorator.BuildOnlyShared()



	module.compiler = apiStubDecorator

	module.linker = apiStubDecorator

	module.installer = nil

	module.library = apiStubDecorator

	module.Properties.HideFromMake = true // TODO: remove



	android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibBoth)

	module.AddProperties(&module.Properties,

		&apiStubDecorator.properties,

		&apiStubDecorator.MutatedProperties,

		&apiStubDecorator.apiStubLibraryProperties)

	return module

}



type apiStubLiraryProperties struct {

	Imported_includes []string `android:"path"`

}



type apiStubDecorator struct {

	*libraryDecorator

	properties               libraryProperties

	apiStubLibraryProperties apiStubLiraryProperties

}



func (compiler *apiStubDecorator) stubsVersions(ctx android.BaseMutatorContext) []string {

	firstVersion := String(compiler.properties.First_version)

	return ndkLibraryVersions(ctx, android.ApiLevelOrPanic(ctx, firstVersion))

}



func (decorator *apiStubDecorator) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects {

	if decorator.stubsVersion() == "" {

		decorator.setStubsVersion("current")

	} // TODO: fix

	symbolFile := String(decorator.properties.Symbol_file)

	nativeAbiResult := parseNativeAbiDefinition(ctx, symbolFile,

		android.ApiLevelOrPanic(ctx, decorator.stubsVersion()),

		"")

	return compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)

}



func (decorator *apiStubDecorator) link(ctx ModuleContext, flags Flags, deps PathDeps, objects Objects) android.Path {

	decorator.reexportDirs(android.PathsForModuleSrc(ctx, decorator.apiStubLibraryProperties.Imported_includes)...)

	return decorator.libraryDecorator.link(ctx, flags, deps, objects)

}



func init() {

	pctx.HostBinToolVariable("gen_api_surface_build_files", "gen_api_surface_build_files")

}



type CcApiContribution struct {

	android.ModuleBase

	properties ccApiContributionProperties

}



type ccApiContributionProperties struct {

	Symbol_file        *string `android:"path"`

	First_version      *string

	Export_include_dir *string

}



func CcApiContributionFactory() android.Module {

	module := &CcApiContribution{}

	module.AddProperties(&module.properties)

	android.InitAndroidModule(module)

	return module

}



// Do some simple validations

// Majority of the build rules will be created in the ctx of the api surface this module contributes to

func (contrib *CcApiContribution) GenerateAndroidBuildActions(ctx android.ModuleContext) {

	if contrib.properties.Symbol_file == nil {

		ctx.PropertyErrorf("symbol_file", "%v does not have symbol file", ctx.ModuleName())

	}

	if contrib.properties.First_version == nil {

		ctx.PropertyErrorf("first_version", "%v does not have first_version for stub variants", ctx.ModuleName())

	}

}



// Path is out/soong/.export/ but will be different in final multi-tree layout

func outPathApiSurface(ctx android.ModuleContext, myModuleName string, pathComponent string) android.OutputPath {

	return android.PathForOutput(ctx, ".export", ctx.ModuleName(), myModuleName, pathComponent)

}



func (contrib *CcApiContribution) CopyFilesWithTag(apiSurfaceContext android.ModuleContext) map[string]android.Paths {

	// copy map.txt for now

	// hardlinks cannot be created since nsjail creates a different mountpoint for out/

	myDir := apiSurfaceContext.OtherModuleDir(contrib)

	genMapTxt := outPathApiSurface(apiSurfaceContext, contrib.Name(), String(contrib.properties.Symbol_file))

	apiSurfaceContext.Build(pctx, android.BuildParams{

		Rule:        android.Cp,

		Description: "import map.txt file",

		Input:       android.PathForSource(apiSurfaceContext, myDir, String(contrib.properties.Symbol_file)),

		Output:      genMapTxt,

	})



	outputs := make(map[string]android.Paths)

	outputs["map"] = []android.Path{genMapTxt}



	if contrib.properties.Export_include_dir != nil {

		includeDir := android.PathForSource(apiSurfaceContext, myDir, String(contrib.properties.Export_include_dir))

		outputs["export_include_dir"] = []android.Path{includeDir}

	}

	return outputs

}



var _ multitree.ApiContribution = (*CcApiContribution)(nil)



/*

func (contrib *CcApiContribution) GenerateBuildFiles(apiSurfaceContext android.ModuleContext) android.Paths {

	genAndroidBp := outPathApiSurface(apiSurfaceContext, contrib.Name(), "Android.bp")



	// generate Android.bp

	apiSurfaceContext.Build(pctx, android.BuildParams{

		Rule:        genApiSurfaceBuildFiles,

		Description: "generate API surface build files",

		Outputs:     []android.WritablePath{genAndroidBp},

		Args: map[string]string{

			"name":          contrib.Name() + "." + apiSurfaceContext.ModuleName(), //e.g. liblog.ndk

			"symbol_file":   String(contrib.properties.Symbol_file),

			"first_version": String(contrib.properties.First_version),

		},

	})

	return []android.Path{genAndroidBp}

}

*/

cc/library_stub_test.go

+0 −84
Original line number Diff line number Diff line
@@ -21,94 +21,10 @@ import ( 
	"testing"



	"android/soong/android"

	"android/soong/multitree"



	"github.com/google/blueprint"

)



func TestCcApiStubLibraryOutputFiles(t *testing.T) {

	bp := `

		cc_api_stub_library {

			name: "foo",

			symbol_file: "foo.map.txt",

			first_version: "29",

		}

	`

	result := prepareForCcTest.RunTestWithBp(t, bp)

	outputs := result.ModuleForTests("foo", "android_arm64_armv8-a_shared").AllOutputs()

	expected_file_suffixes := []string{".c", "stub.map", ".o", ".so"}

	for _, expected_file_suffix := range expected_file_suffixes {

		android.AssertBoolEquals(t, expected_file_suffix+" file not found in output", true, android.SuffixInList(outputs, expected_file_suffix))

	}

}



func TestCcApiStubLibraryVariants(t *testing.T) {

	bp := `

		cc_api_stub_library {

			name: "foo",

			symbol_file: "foo.map.txt",

			first_version: "29",

		}

	`

	result := prepareForCcTest.RunTestWithBp(t, bp)

	variants := result.ModuleVariantsForTests("foo")

	expected_variants := []string{"29", "30", "S", "Tiramisu"} //TODO: make this test deterministic by using fixtures

	for _, expected_variant := range expected_variants {

		android.AssertBoolEquals(t, expected_variant+" variant not found in foo", true, android.SubstringInList(variants, expected_variant))

	}

}



func TestCcLibraryUsesCcApiStubLibrary(t *testing.T) {

	bp := `

		cc_api_stub_library {

			name: "foo",

			symbol_file: "foo.map.txt",

			first_version: "29",

		}

		cc_library {

			name: "foo_user",

			shared_libs: [

				"foo#29",

			],

		}



	`

	prepareForCcTest.RunTestWithBp(t, bp)

}



func TestApiSurfaceOutputs(t *testing.T) {

	bp := `

		api_surface {

			name: "mysdk",

			contributions: [

				"foo",

			],

		}



		cc_api_contribution {

			name: "foo",

			symbol_file: "foo.map.txt",

			first_version: "29",

		}

	`

	result := android.GroupFixturePreparers(

		prepareForCcTest,

		multitree.PrepareForTestWithApiSurface,

	).RunTestWithBp(t, bp)

	mysdk := result.ModuleForTests("mysdk", "")



	actual_surface_inputs := mysdk.Rule("phony").BuildParams.Inputs.Strings()

	expected_file_suffixes := []string{"mysdk/foo/foo.map.txt"}

	for _, expected_file_suffix := range expected_file_suffixes {

		android.AssertBoolEquals(t, expected_file_suffix+" file not found in input", true, android.SuffixInList(actual_surface_inputs, expected_file_suffix))

	}



	// check args/inputs to rule

	/*api_surface_gen_rule_args := result.ModuleForTests("mysdk", "").Rule("genApiSurfaceBuildFiles").Args

	android.AssertStringEquals(t, "name", "foo.mysdk", api_surface_gen_rule_args["name"])

	android.AssertStringEquals(t, "symbol_file", "foo.map.txt", api_surface_gen_rule_args["symbol_file"])*/

}



func hasDirectDependency(t *testing.T, ctx *android.TestResult, from android.Module, to android.Module) bool {

	t.Helper()

	var found bool