cc/ndk_library.go

// Copyright 2016 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package cc

import (
	"fmt"
	"strconv"
	"strings"

	"github.com/google/blueprint"

	"android/soong/android"
)

var (
	toolPath = pctx.SourcePathVariable("toolPath", "build/soong/cc/gen_stub_libs.py")

	genStubSrc = pctx.StaticRule("genStubSrc",
		blueprint.RuleParams{
			Command:     "$toolPath --arch $arch --api $apiLevel $in $out",
			Description: "genStubSrc $out",
			CommandDeps: []string{"$toolPath"},
		}, "arch", "apiLevel")

	ndkLibrarySuffix = ".ndk"

	ndkPrebuiltSharedLibs = []string{
		"android",
		"c",
		"dl",
		"EGL",
		"GLESv1_CM",
		"GLESv2",
		"GLESv3",
		"jnigraphics",
		"log",
		"mediandk",
		"m",
		"OpenMAXAL",
		"OpenSLES",
		"stdc++",
		"vulkan",
		"z",
	}
	ndkPrebuiltSharedLibraries = addPrefix(append([]string(nil), ndkPrebuiltSharedLibs...), "lib")

	// These libraries have migrated over to the new ndk_library, which is added
	// as a variation dependency via depsMutator.
	ndkMigratedLibs = []string{}
)

// Creates a stub shared library based on the provided version file.
//
// The name of the generated file will be based on the module name by stripping
// the ".ndk" suffix from the module name. Module names must end with ".ndk"
// (as a convention to allow soong to guess the NDK name of a dependency when
// needed). "libfoo.ndk" will generate "libfoo.so.
//
// Example:
//
// ndk_library {
//     name: "libfoo.ndk",
//     symbol_file: "libfoo.map.txt",
//     first_version: "9",
// }
//
type libraryProperties struct {
	// Relative path to the symbol map.
	// An example file can be seen here: TODO(danalbert): Make an example.
	Symbol_file string

	// The first API level a library was available. A library will be generated
	// for every API level beginning with this one.
	First_version string

	// Private property for use by the mutator that splits per-API level.
	ApiLevel int `blueprint:"mutated"`
}

type stubCompiler struct {
	baseCompiler

	properties libraryProperties

	linker *stubLinker
}

// OMG GO
func intMin(a int, b int) int {
	if a < b {
		return a
	} else {
		return b
	}
}

func generateStubApiVariants(mctx android.BottomUpMutatorContext, c *stubCompiler) {
	minVersion := 9 // Minimum version supported by the NDK.
	// TODO(danalbert): Use PlatformSdkVersion when possible.
	// This is an interesting case because for the moment we actually need 24
	// even though the latest released version in aosp is 23. prebuilts/ndk/r11
	// has android-24 versions of libraries, and as platform libraries get
	// migrated the libraries in prebuilts will need to depend on them.
	//
	// Once everything is all moved over to the new stuff (when there isn't a
	// prebuilts/ndk any more) then this should be fixable, but for now I think
	// it needs to remain as-is.
	maxVersion := 24
	firstArchVersions := map[string]int{
		"arm":    9,
		"arm64":  21,
		"mips":   9,
		"mips64": 21,
		"x86":    9,
		"x86_64": 21,
	}

	// If the NDK drops support for a platform version, we don't want to have to
	// fix up every module that was using it as its minimum version. Clip to the
	// supported version here instead.
	firstVersion, err := strconv.Atoi(c.properties.First_version)
	if err != nil {
		mctx.ModuleErrorf("Invalid first_version value (must be int): %q",
			c.properties.First_version)
	}
	if firstVersion < minVersion {
		firstVersion = minVersion
	}

	arch := mctx.Arch().ArchType.String()
	firstArchVersion, ok := firstArchVersions[arch]
	if !ok {
		panic(fmt.Errorf("Arch %q not found in firstArchVersions", arch))
	}
	firstGenVersion := intMin(firstVersion, firstArchVersion)
	versionStrs := make([]string, maxVersion-firstGenVersion+1)
	for version := firstGenVersion; version <= maxVersion; version++ {
		versionStrs[version-firstGenVersion] = strconv.Itoa(version)
	}

	modules := mctx.CreateVariations(versionStrs...)
	for i, module := range modules {
		module.(*Module).compiler.(*stubCompiler).properties.ApiLevel = firstGenVersion + i
	}
}

func ndkApiMutator(mctx android.BottomUpMutatorContext) {
	if m, ok := mctx.Module().(*Module); ok {
		if compiler, ok := m.compiler.(*stubCompiler); ok {
			generateStubApiVariants(mctx, compiler)
		}
	}
}

func (c *stubCompiler) compile(ctx ModuleContext, flags Flags, deps PathDeps) android.Paths {
	arch := ctx.Arch().ArchType.String()

	if !strings.HasSuffix(ctx.ModuleName(), ndkLibrarySuffix) {
		ctx.ModuleErrorf("ndk_library modules names must be suffixed with %q\n",
			ndkLibrarySuffix)
	}
	libName := strings.TrimSuffix(ctx.ModuleName(), ndkLibrarySuffix)
	fileBase := fmt.Sprintf("%s.%s.%d", libName, arch, c.properties.ApiLevel)
	stubSrcName := fileBase + ".c"
	stubSrcPath := android.PathForModuleGen(ctx, stubSrcName)
	versionScriptName := fileBase + ".map"
	versionScriptPath := android.PathForModuleGen(ctx, versionScriptName)
	c.linker.versionScriptPath = versionScriptPath
	symbolFilePath := android.PathForModuleSrc(ctx, c.properties.Symbol_file)
	ctx.ModuleBuild(pctx, android.ModuleBuildParams{
		Rule:    genStubSrc,
		Outputs: []android.WritablePath{stubSrcPath, versionScriptPath},
		Input:   symbolFilePath,
		Args: map[string]string{
			"arch":     arch,
			"apiLevel": strconv.Itoa(c.properties.ApiLevel),
		},
	})

	flags.CFlags = append(flags.CFlags,
		// We're knowingly doing some otherwise unsightly things with builtin
		// functions here. We're just generating stub libraries, so ignore it.
		"-Wno-incompatible-library-redeclaration",
		"-Wno-builtin-requires-header",
		"-Wno-invalid-noreturn",

		// These libraries aren't actually used. Don't worry about unwinding
		// (avoids the need to link an unwinder into a fake library).
		"-fno-unwind-tables",
	)

	subdir := ""
	srcs := []string{}
	excludeSrcs := []string{}
	extraSrcs := []android.Path{stubSrcPath}
	extraDeps := []android.Path{}
	return c.baseCompiler.compileObjs(ctx, flags, subdir, srcs, excludeSrcs,
		extraSrcs, extraDeps)
}

type stubLinker struct {
	libraryLinker

	versionScriptPath android.ModuleGenPath
}

func (linker *stubLinker) linkerDeps(ctx BaseModuleContext, deps Deps) Deps {
	return Deps{}
}

func (linker *stubLinker) linkerFlags(ctx ModuleContext, flags Flags) Flags {
	linker.libraryLinker.libName = strings.TrimSuffix(ctx.ModuleName(),
		ndkLibrarySuffix)
	return linker.libraryLinker.linkerFlags(ctx, flags)
}

func (linker *stubLinker) link(ctx ModuleContext, flags Flags, deps PathDeps,
	objFiles android.Paths) android.Path {

	linkerScriptFlag := "-Wl,--version-script," + linker.versionScriptPath.String()
	flags.LdFlags = append(flags.LdFlags, linkerScriptFlag)
	return linker.libraryLinker.link(ctx, flags, deps, objFiles)
}

type stubInstaller struct {
	baseInstaller

	compiler *stubCompiler

	installPath string
}

var _ installer = (*stubInstaller)(nil)

func (installer *stubInstaller) install(ctx ModuleContext, path android.Path) {
	arch := ctx.Target().Arch.ArchType.Name
	apiLevel := installer.compiler.properties.ApiLevel

	// arm64 isn't actually a multilib toolchain, so unlike the other LP64
	// architectures it's just installed to lib.
	libDir := "lib"
	if ctx.toolchain().Is64Bit() && arch != "arm64" {
		libDir = "lib64"
	}

	installDir := getNdkInstallBase(ctx).Join(ctx, fmt.Sprintf(
		"platforms/android-%d/arch-%s/usr/%s", apiLevel, arch, libDir))
	installer.installPath = ctx.InstallFile(installDir, path).String()
}

func newStubLibrary() *Module {
	module := newModule(android.DeviceSupported, android.MultilibBoth)
	module.stl = nil

	linker := &stubLinker{}
	linker.dynamicProperties.BuildShared = true
	linker.dynamicProperties.BuildStatic = false
	linker.stripper.StripProperties.Strip.None = true
	module.linker = linker

	compiler := &stubCompiler{}
	compiler.linker = linker
	module.compiler = compiler
	module.installer = &stubInstaller{baseInstaller{
		dir:   "lib",
		dir64: "lib64",
	}, compiler, ""}

	return module
}

func ndkLibraryFactory() (blueprint.Module, []interface{}) {
	module := newStubLibrary()
	return android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibBoth,
		&module.compiler.(*stubCompiler).properties)
}