729 lines
26 KiB
Go
729 lines
26 KiB
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"
|
|
"path/filepath"
|
|
"regexp"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/google/blueprint/proptools"
|
|
|
|
"android/soong/android"
|
|
"android/soong/cc/config"
|
|
)
|
|
|
|
var (
|
|
allowedManualInterfacePaths = []string{"vendor/", "hardware/"}
|
|
)
|
|
|
|
// This file contains the basic C/C++/assembly to .o compliation steps
|
|
|
|
type BaseCompilerProperties struct {
|
|
// list of source files used to compile the C/C++ module. May be .c, .cpp, or .S files.
|
|
// srcs may reference the outputs of other modules that produce source files like genrule
|
|
// or filegroup using the syntax ":module".
|
|
Srcs []string `android:"path,arch_variant"`
|
|
|
|
// list of source files that should not be used to build the C/C++ module.
|
|
// This is most useful in the arch/multilib variants to remove non-common files
|
|
Exclude_srcs []string `android:"path,arch_variant"`
|
|
|
|
// list of module-specific flags that will be used for C and C++ compiles.
|
|
Cflags []string `android:"arch_variant"`
|
|
|
|
// list of module-specific flags that will be used for C++ compiles
|
|
Cppflags []string `android:"arch_variant"`
|
|
|
|
// list of module-specific flags that will be used for C compiles
|
|
Conlyflags []string `android:"arch_variant"`
|
|
|
|
// list of module-specific flags that will be used for .S compiles
|
|
Asflags []string `android:"arch_variant"`
|
|
|
|
// list of module-specific flags that will be used for C and C++ compiles when
|
|
// compiling with clang
|
|
Clang_cflags []string `android:"arch_variant"`
|
|
|
|
// list of module-specific flags that will be used for .S compiles when
|
|
// compiling with clang
|
|
Clang_asflags []string `android:"arch_variant"`
|
|
|
|
// the instruction set architecture to use to compile the C/C++
|
|
// module.
|
|
Instruction_set *string `android:"arch_variant"`
|
|
|
|
// list of directories relative to the root of the source tree that will
|
|
// be added to the include path using -I.
|
|
// If possible, don't use this. If adding paths from the current directory use
|
|
// local_include_dirs, if adding paths from other modules use export_include_dirs in
|
|
// that module.
|
|
Include_dirs []string `android:"arch_variant,variant_prepend"`
|
|
|
|
// list of directories relative to the Blueprints file that will
|
|
// be added to the include path using -I
|
|
Local_include_dirs []string `android:"arch_variant,variant_prepend"`
|
|
|
|
// Add the directory containing the Android.bp file to the list of include
|
|
// directories. Defaults to true.
|
|
Include_build_directory *bool
|
|
|
|
// list of generated sources to compile. These are the names of gensrcs or
|
|
// genrule modules.
|
|
Generated_sources []string `android:"arch_variant"`
|
|
|
|
// list of generated sources that should not be used to build the C/C++ module.
|
|
// This is most useful in the arch/multilib variants to remove non-common files
|
|
Exclude_generated_sources []string `android:"arch_variant"`
|
|
|
|
// list of generated headers to add to the include path. These are the names
|
|
// of genrule modules.
|
|
Generated_headers []string `android:"arch_variant"`
|
|
|
|
// pass -frtti instead of -fno-rtti
|
|
Rtti *bool
|
|
|
|
// C standard version to use. Can be a specific version (such as "gnu11"),
|
|
// "experimental" (which will use draft versions like C1x when available),
|
|
// or the empty string (which will use the default).
|
|
C_std *string
|
|
|
|
// C++ standard version to use. Can be a specific version (such as
|
|
// "gnu++11"), "experimental" (which will use draft versions like C++1z when
|
|
// available), or the empty string (which will use the default).
|
|
Cpp_std *string
|
|
|
|
// if set to false, use -std=c++* instead of -std=gnu++*
|
|
Gnu_extensions *bool
|
|
|
|
Yacc *YaccProperties
|
|
Lex *LexProperties
|
|
|
|
Aidl struct {
|
|
// list of directories that will be added to the aidl include paths.
|
|
Include_dirs []string
|
|
|
|
// list of directories relative to the Blueprints file that will
|
|
// be added to the aidl include paths.
|
|
Local_include_dirs []string
|
|
|
|
// whether to generate traces (for systrace) for this interface
|
|
Generate_traces *bool
|
|
|
|
// list of flags that will be passed to the AIDL compiler
|
|
Flags []string
|
|
}
|
|
|
|
Renderscript struct {
|
|
// list of directories that will be added to the llvm-rs-cc include paths
|
|
Include_dirs []string
|
|
|
|
// list of flags that will be passed to llvm-rs-cc
|
|
Flags []string
|
|
|
|
// Renderscript API level to target
|
|
Target_api *string
|
|
}
|
|
|
|
Debug, Release struct {
|
|
// list of module-specific flags that will be used for C and C++ compiles in debug or
|
|
// release builds
|
|
Cflags []string `android:"arch_variant"`
|
|
} `android:"arch_variant"`
|
|
|
|
Target struct {
|
|
Vendor, Product struct {
|
|
// list of source files that should only be used in vendor or
|
|
// product variant of the C/C++ module.
|
|
Srcs []string `android:"path"`
|
|
|
|
// list of source files that should not be used to build vendor
|
|
// or product variant of the C/C++ module.
|
|
Exclude_srcs []string `android:"path"`
|
|
|
|
// List of additional cflags that should be used to build vendor
|
|
// or product variant of the C/C++ module.
|
|
Cflags []string
|
|
|
|
// list of generated sources that should not be used to build
|
|
// vendor or product variant of the C/C++ module.
|
|
Exclude_generated_sources []string
|
|
}
|
|
Recovery struct {
|
|
// list of source files that should only be used in the
|
|
// recovery variant of the C/C++ module.
|
|
Srcs []string `android:"path"`
|
|
|
|
// list of source files that should not be used to
|
|
// build the recovery variant of the C/C++ module.
|
|
Exclude_srcs []string `android:"path"`
|
|
|
|
// List of additional cflags that should be used to build the recovery
|
|
// variant of the C/C++ module.
|
|
Cflags []string
|
|
|
|
// list of generated sources that should not be used to
|
|
// build the recovery variant of the C/C++ module.
|
|
Exclude_generated_sources []string
|
|
}
|
|
Vendor_ramdisk struct {
|
|
// list of source files that should not be used to
|
|
// build the vendor ramdisk variant of the C/C++ module.
|
|
Exclude_srcs []string `android:"path"`
|
|
|
|
// List of additional cflags that should be used to build the vendor ramdisk
|
|
// variant of the C/C++ module.
|
|
Cflags []string
|
|
}
|
|
}
|
|
|
|
Proto struct {
|
|
// Link statically against the protobuf runtime
|
|
Static *bool `android:"arch_variant"`
|
|
} `android:"arch_variant"`
|
|
|
|
// Stores the original list of source files before being cleared by library reuse
|
|
OriginalSrcs []string `blueprint:"mutated"`
|
|
|
|
// Build and link with OpenMP
|
|
Openmp *bool `android:"arch_variant"`
|
|
|
|
// Deprecated.
|
|
// Adds __ANDROID_APEX_<APEX_MODULE_NAME>__ macro defined for apex variants in addition to __ANDROID_APEX__
|
|
Use_apex_name_macro *bool
|
|
|
|
// Adds two macros for apex variants in addition to __ANDROID_APEX__
|
|
// * __ANDROID_APEX_COM_ANDROID_FOO__
|
|
// * __ANDROID_APEX_NAME__="com.android.foo"
|
|
UseApexNameMacro bool `blueprint:"mutated"`
|
|
}
|
|
|
|
func NewBaseCompiler() *baseCompiler {
|
|
return &baseCompiler{}
|
|
}
|
|
|
|
type baseCompiler struct {
|
|
Properties BaseCompilerProperties
|
|
Proto android.ProtoProperties
|
|
cFlagsDeps android.Paths
|
|
pathDeps android.Paths
|
|
flags builderFlags
|
|
|
|
// Sources that were passed to the C/C++ compiler
|
|
srcs android.Paths
|
|
|
|
// Sources that were passed in the Android.bp file, including generated sources generated by
|
|
// other modules and filegroups. May include source files that have not yet been translated to
|
|
// C/C++ (.aidl, .proto, etc.)
|
|
srcsBeforeGen android.Paths
|
|
|
|
generatedSourceInfo
|
|
}
|
|
|
|
var _ compiler = (*baseCompiler)(nil)
|
|
|
|
type CompiledInterface interface {
|
|
Srcs() android.Paths
|
|
}
|
|
|
|
func (compiler *baseCompiler) Srcs() android.Paths {
|
|
return append(android.Paths{}, compiler.srcs...)
|
|
}
|
|
|
|
func (compiler *baseCompiler) appendCflags(flags []string) {
|
|
compiler.Properties.Cflags = append(compiler.Properties.Cflags, flags...)
|
|
}
|
|
|
|
func (compiler *baseCompiler) appendAsflags(flags []string) {
|
|
compiler.Properties.Asflags = append(compiler.Properties.Asflags, flags...)
|
|
}
|
|
|
|
func (compiler *baseCompiler) compilerProps() []interface{} {
|
|
return []interface{}{&compiler.Properties, &compiler.Proto}
|
|
}
|
|
|
|
func (compiler *baseCompiler) compilerInit(ctx BaseModuleContext) {}
|
|
|
|
func (compiler *baseCompiler) compilerDeps(ctx DepsContext, deps Deps) Deps {
|
|
deps.GeneratedSources = append(deps.GeneratedSources, compiler.Properties.Generated_sources...)
|
|
deps.GeneratedSources = removeListFromList(deps.GeneratedSources, compiler.Properties.Exclude_generated_sources)
|
|
deps.GeneratedHeaders = append(deps.GeneratedHeaders, compiler.Properties.Generated_headers...)
|
|
|
|
android.ProtoDeps(ctx, &compiler.Proto)
|
|
if compiler.hasSrcExt(".proto") {
|
|
deps = protoDeps(ctx, deps, &compiler.Proto, Bool(compiler.Properties.Proto.Static))
|
|
}
|
|
|
|
if Bool(compiler.Properties.Openmp) {
|
|
deps.StaticLibs = append(deps.StaticLibs, "libomp")
|
|
}
|
|
|
|
return deps
|
|
}
|
|
|
|
func (compiler *baseCompiler) useApexNameMacro() bool {
|
|
return Bool(compiler.Properties.Use_apex_name_macro) || compiler.Properties.UseApexNameMacro
|
|
}
|
|
|
|
// Return true if the module is in the WarningAllowedProjects.
|
|
func warningsAreAllowed(subdir string) bool {
|
|
subdir += "/"
|
|
return android.HasAnyPrefix(subdir, config.WarningAllowedProjects)
|
|
}
|
|
|
|
func addToModuleList(ctx ModuleContext, key android.OnceKey, module string) {
|
|
getNamedMapForConfig(ctx.Config(), key).Store(module, true)
|
|
}
|
|
|
|
// Create a Flags struct that collects the compile flags from global values,
|
|
// per-target values, module type values, and per-module Blueprints properties
|
|
func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags {
|
|
tc := ctx.toolchain()
|
|
modulePath := android.PathForModuleSrc(ctx).String()
|
|
|
|
compiler.srcsBeforeGen = android.PathsForModuleSrcExcludes(ctx, compiler.Properties.Srcs, compiler.Properties.Exclude_srcs)
|
|
compiler.srcsBeforeGen = append(compiler.srcsBeforeGen, deps.GeneratedSources...)
|
|
|
|
CheckBadCompilerFlags(ctx, "cflags", compiler.Properties.Cflags)
|
|
CheckBadCompilerFlags(ctx, "cppflags", compiler.Properties.Cppflags)
|
|
CheckBadCompilerFlags(ctx, "conlyflags", compiler.Properties.Conlyflags)
|
|
CheckBadCompilerFlags(ctx, "asflags", compiler.Properties.Asflags)
|
|
CheckBadCompilerFlags(ctx, "vendor.cflags", compiler.Properties.Target.Vendor.Cflags)
|
|
CheckBadCompilerFlags(ctx, "product.cflags", compiler.Properties.Target.Product.Cflags)
|
|
CheckBadCompilerFlags(ctx, "recovery.cflags", compiler.Properties.Target.Recovery.Cflags)
|
|
CheckBadCompilerFlags(ctx, "vendor_ramdisk.cflags", compiler.Properties.Target.Vendor_ramdisk.Cflags)
|
|
|
|
esc := proptools.NinjaAndShellEscapeList
|
|
|
|
flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Cflags)...)
|
|
flags.Local.CppFlags = append(flags.Local.CppFlags, esc(compiler.Properties.Cppflags)...)
|
|
flags.Local.ConlyFlags = append(flags.Local.ConlyFlags, esc(compiler.Properties.Conlyflags)...)
|
|
flags.Local.AsFlags = append(flags.Local.AsFlags, esc(compiler.Properties.Asflags)...)
|
|
flags.Local.YasmFlags = append(flags.Local.YasmFlags, esc(compiler.Properties.Asflags)...)
|
|
|
|
flags.Yacc = compiler.Properties.Yacc
|
|
flags.Lex = compiler.Properties.Lex
|
|
|
|
// Include dir cflags
|
|
localIncludeDirs := android.PathsForModuleSrc(ctx, compiler.Properties.Local_include_dirs)
|
|
if len(localIncludeDirs) > 0 {
|
|
f := includeDirsToFlags(localIncludeDirs)
|
|
flags.Local.CommonFlags = append(flags.Local.CommonFlags, f)
|
|
flags.Local.YasmFlags = append(flags.Local.YasmFlags, f)
|
|
}
|
|
rootIncludeDirs := android.PathsForSource(ctx, compiler.Properties.Include_dirs)
|
|
if len(rootIncludeDirs) > 0 {
|
|
f := includeDirsToFlags(rootIncludeDirs)
|
|
flags.Local.CommonFlags = append(flags.Local.CommonFlags, f)
|
|
flags.Local.YasmFlags = append(flags.Local.YasmFlags, f)
|
|
}
|
|
|
|
if compiler.Properties.Include_build_directory == nil ||
|
|
*compiler.Properties.Include_build_directory {
|
|
flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+modulePath)
|
|
flags.Local.YasmFlags = append(flags.Local.YasmFlags, "-I"+modulePath)
|
|
}
|
|
|
|
if !(ctx.useSdk() || ctx.useVndk()) || ctx.Host() {
|
|
flags.SystemIncludeFlags = append(flags.SystemIncludeFlags,
|
|
"${config.CommonGlobalIncludes}",
|
|
tc.IncludeFlags())
|
|
}
|
|
|
|
if ctx.useSdk() {
|
|
// TODO: Switch to --sysroot.
|
|
// The NDK headers are installed to a common sysroot. While a more
|
|
// typical Soong approach would be to only make the headers for the
|
|
// library you're using available, we're trying to emulate the NDK
|
|
// behavior here, and the NDK always has all the NDK headers available.
|
|
flags.SystemIncludeFlags = append(flags.SystemIncludeFlags,
|
|
"-isystem "+getCurrentIncludePath(ctx).String(),
|
|
"-isystem "+getCurrentIncludePath(ctx).Join(ctx, config.NDKTriple(tc)).String())
|
|
}
|
|
|
|
if ctx.useVndk() {
|
|
flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_VNDK__")
|
|
}
|
|
|
|
if ctx.inRecovery() {
|
|
flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_RECOVERY__")
|
|
}
|
|
|
|
if ctx.apexVariationName() != "" {
|
|
flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_APEX__")
|
|
if compiler.useApexNameMacro() {
|
|
flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_APEX_"+makeDefineString(ctx.apexVariationName())+"__")
|
|
flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_APEX_NAME__='\""+ctx.apexVariationName()+"\"'")
|
|
}
|
|
if ctx.Device() {
|
|
flags.Global.CommonFlags = append(flags.Global.CommonFlags,
|
|
fmt.Sprintf("-D__ANDROID_APEX_MIN_SDK_VERSION__=%d",
|
|
ctx.apexSdkVersion().FinalOrFutureInt()))
|
|
}
|
|
}
|
|
|
|
if ctx.Target().NativeBridge == android.NativeBridgeEnabled {
|
|
flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_NATIVE_BRIDGE__")
|
|
}
|
|
|
|
instructionSet := String(compiler.Properties.Instruction_set)
|
|
if flags.RequiredInstructionSet != "" {
|
|
instructionSet = flags.RequiredInstructionSet
|
|
}
|
|
instructionSetFlags, err := tc.ClangInstructionSetFlags(instructionSet)
|
|
if err != nil {
|
|
ctx.ModuleErrorf("%s", err)
|
|
}
|
|
|
|
CheckBadCompilerFlags(ctx, "release.cflags", compiler.Properties.Release.Cflags)
|
|
|
|
// TODO: debug
|
|
flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Release.Cflags)...)
|
|
|
|
CheckBadCompilerFlags(ctx, "clang_cflags", compiler.Properties.Clang_cflags)
|
|
CheckBadCompilerFlags(ctx, "clang_asflags", compiler.Properties.Clang_asflags)
|
|
|
|
flags.Local.CFlags = config.ClangFilterUnknownCflags(flags.Local.CFlags)
|
|
flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Clang_cflags)...)
|
|
flags.Local.AsFlags = append(flags.Local.AsFlags, esc(compiler.Properties.Clang_asflags)...)
|
|
flags.Local.CppFlags = config.ClangFilterUnknownCflags(flags.Local.CppFlags)
|
|
flags.Local.ConlyFlags = config.ClangFilterUnknownCflags(flags.Local.ConlyFlags)
|
|
flags.Local.LdFlags = config.ClangFilterUnknownCflags(flags.Local.LdFlags)
|
|
|
|
target := "-target " + tc.ClangTriple()
|
|
if ctx.Os().Class == android.Device {
|
|
// When built for the non-updateble part of platform, minSdkVersion doesn't matter.
|
|
// It matters only when building we are building for modules that can be unbundled.
|
|
version := "current"
|
|
if !ctx.isForPlatform() || ctx.isSdkVariant() {
|
|
version = ctx.minSdkVersion()
|
|
}
|
|
if version == "" || version == "current" {
|
|
target += strconv.Itoa(android.FutureApiLevelInt)
|
|
} else {
|
|
target += version
|
|
}
|
|
}
|
|
|
|
gccPrefix := "-B" + config.ToolPath(tc)
|
|
|
|
flags.Global.CFlags = append(flags.Global.CFlags, target, gccPrefix)
|
|
flags.Global.AsFlags = append(flags.Global.AsFlags, target, gccPrefix)
|
|
flags.Global.LdFlags = append(flags.Global.LdFlags, target, gccPrefix)
|
|
|
|
hod := "Host"
|
|
if ctx.Os().Class == android.Device {
|
|
hod = "Device"
|
|
}
|
|
|
|
flags.Global.CommonFlags = append(flags.Global.CommonFlags, instructionSetFlags)
|
|
flags.Global.ConlyFlags = append([]string{"${config.CommonGlobalConlyflags}"}, flags.Global.ConlyFlags...)
|
|
flags.Global.CppFlags = append([]string{fmt.Sprintf("${config.%sGlobalCppflags}", hod)}, flags.Global.CppFlags...)
|
|
|
|
flags.Global.AsFlags = append(flags.Global.AsFlags, tc.ClangAsflags())
|
|
flags.Global.CppFlags = append([]string{"${config.CommonClangGlobalCppflags}"}, flags.Global.CppFlags...)
|
|
flags.Global.CommonFlags = append(flags.Global.CommonFlags,
|
|
tc.ClangCflags(),
|
|
"${config.CommonClangGlobalCflags}",
|
|
fmt.Sprintf("${config.%sClangGlobalCflags}", hod))
|
|
|
|
if isThirdParty(modulePath) {
|
|
flags.Global.CommonFlags = append(flags.Global.CommonFlags, "${config.ClangExternalCflags}")
|
|
}
|
|
|
|
if tc.Bionic() {
|
|
if Bool(compiler.Properties.Rtti) {
|
|
flags.Local.CppFlags = append(flags.Local.CppFlags, "-frtti")
|
|
} else {
|
|
flags.Local.CppFlags = append(flags.Local.CppFlags, "-fno-rtti")
|
|
}
|
|
}
|
|
|
|
flags.Global.AsFlags = append(flags.Global.AsFlags, "-D__ASSEMBLY__")
|
|
|
|
flags.Global.CppFlags = append(flags.Global.CppFlags, tc.ClangCppflags())
|
|
|
|
flags.Global.YasmFlags = append(flags.Global.YasmFlags, tc.YasmFlags())
|
|
|
|
flags.Global.CommonFlags = append(flags.Global.CommonFlags, tc.ToolchainClangCflags())
|
|
|
|
cStd := config.CStdVersion
|
|
if String(compiler.Properties.C_std) == "experimental" {
|
|
cStd = config.ExperimentalCStdVersion
|
|
} else if String(compiler.Properties.C_std) != "" {
|
|
cStd = String(compiler.Properties.C_std)
|
|
}
|
|
|
|
cppStd := String(compiler.Properties.Cpp_std)
|
|
switch String(compiler.Properties.Cpp_std) {
|
|
case "":
|
|
cppStd = config.CppStdVersion
|
|
case "experimental":
|
|
cppStd = config.ExperimentalCppStdVersion
|
|
}
|
|
|
|
if compiler.Properties.Gnu_extensions != nil && *compiler.Properties.Gnu_extensions == false {
|
|
cStd = gnuToCReplacer.Replace(cStd)
|
|
cppStd = gnuToCReplacer.Replace(cppStd)
|
|
}
|
|
|
|
flags.Local.ConlyFlags = append([]string{"-std=" + cStd}, flags.Local.ConlyFlags...)
|
|
flags.Local.CppFlags = append([]string{"-std=" + cppStd}, flags.Local.CppFlags...)
|
|
|
|
if ctx.inVendor() {
|
|
flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Vendor.Cflags)...)
|
|
}
|
|
|
|
if ctx.inProduct() {
|
|
flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Product.Cflags)...)
|
|
}
|
|
|
|
if ctx.inRecovery() {
|
|
flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Recovery.Cflags)...)
|
|
}
|
|
|
|
if ctx.inVendorRamdisk() {
|
|
flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Vendor_ramdisk.Cflags)...)
|
|
}
|
|
|
|
// We can enforce some rules more strictly in the code we own. strict
|
|
// indicates if this is code that we can be stricter with. If we have
|
|
// rules that we want to apply to *our* code (but maybe can't for
|
|
// vendor/device specific things), we could extend this to be a ternary
|
|
// value.
|
|
strict := true
|
|
if strings.HasPrefix(modulePath, "external/") {
|
|
strict = false
|
|
}
|
|
|
|
// Can be used to make some annotations stricter for code we can fix
|
|
// (such as when we mark functions as deprecated).
|
|
if strict {
|
|
flags.Global.CFlags = append(flags.Global.CFlags, "-DANDROID_STRICT")
|
|
}
|
|
|
|
if compiler.hasSrcExt(".proto") {
|
|
flags = protoFlags(ctx, flags, &compiler.Proto)
|
|
}
|
|
|
|
if compiler.hasSrcExt(".y") || compiler.hasSrcExt(".yy") {
|
|
flags.Local.CommonFlags = append(flags.Local.CommonFlags,
|
|
"-I"+android.PathForModuleGen(ctx, "yacc", ctx.ModuleDir()).String())
|
|
}
|
|
|
|
if compiler.hasSrcExt(".mc") {
|
|
flags.Local.CommonFlags = append(flags.Local.CommonFlags,
|
|
"-I"+android.PathForModuleGen(ctx, "windmc", ctx.ModuleDir()).String())
|
|
}
|
|
|
|
if compiler.hasSrcExt(".aidl") {
|
|
flags.aidlFlags = append(flags.aidlFlags, compiler.Properties.Aidl.Flags...)
|
|
if len(compiler.Properties.Aidl.Local_include_dirs) > 0 {
|
|
localAidlIncludeDirs := android.PathsForModuleSrc(ctx, compiler.Properties.Aidl.Local_include_dirs)
|
|
flags.aidlFlags = append(flags.aidlFlags, includeDirsToFlags(localAidlIncludeDirs))
|
|
}
|
|
if len(compiler.Properties.Aidl.Include_dirs) > 0 {
|
|
rootAidlIncludeDirs := android.PathsForSource(ctx, compiler.Properties.Aidl.Include_dirs)
|
|
flags.aidlFlags = append(flags.aidlFlags, includeDirsToFlags(rootAidlIncludeDirs))
|
|
}
|
|
|
|
if Bool(compiler.Properties.Aidl.Generate_traces) {
|
|
flags.aidlFlags = append(flags.aidlFlags, "-t")
|
|
}
|
|
|
|
flags.Local.CommonFlags = append(flags.Local.CommonFlags,
|
|
"-I"+android.PathForModuleGen(ctx, "aidl").String())
|
|
}
|
|
|
|
if compiler.hasSrcExt(".rscript") || compiler.hasSrcExt(".fs") {
|
|
flags = rsFlags(ctx, flags, &compiler.Properties)
|
|
}
|
|
|
|
if compiler.hasSrcExt(".sysprop") {
|
|
flags.Local.CommonFlags = append(flags.Local.CommonFlags,
|
|
"-I"+android.PathForModuleGen(ctx, "sysprop", "include").String())
|
|
}
|
|
|
|
if len(compiler.Properties.Srcs) > 0 {
|
|
module := ctx.ModuleDir() + "/Android.bp:" + ctx.ModuleName()
|
|
if inList("-Wno-error", flags.Local.CFlags) || inList("-Wno-error", flags.Local.CppFlags) {
|
|
addToModuleList(ctx, modulesUsingWnoErrorKey, module)
|
|
} else if !inList("-Werror", flags.Local.CFlags) && !inList("-Werror", flags.Local.CppFlags) {
|
|
if warningsAreAllowed(ctx.ModuleDir()) {
|
|
addToModuleList(ctx, modulesAddedWallKey, module)
|
|
flags.Local.CFlags = append([]string{"-Wall"}, flags.Local.CFlags...)
|
|
} else {
|
|
flags.Local.CFlags = append([]string{"-Wall", "-Werror"}, flags.Local.CFlags...)
|
|
}
|
|
}
|
|
}
|
|
|
|
if Bool(compiler.Properties.Openmp) {
|
|
flags.Local.CFlags = append(flags.Local.CFlags, "-fopenmp")
|
|
}
|
|
|
|
// Exclude directories from manual binder interface allowed list.
|
|
//TODO(b/145621474): Move this check into IInterface.h when clang-tidy no longer uses absolute paths.
|
|
if android.HasAnyPrefix(ctx.ModuleDir(), allowedManualInterfacePaths) {
|
|
flags.Local.CFlags = append(flags.Local.CFlags, "-DDO_NOT_CHECK_MANUAL_BINDER_INTERFACES")
|
|
}
|
|
|
|
return flags
|
|
}
|
|
|
|
func (compiler *baseCompiler) hasSrcExt(ext string) bool {
|
|
for _, src := range compiler.srcsBeforeGen {
|
|
if src.Ext() == ext {
|
|
return true
|
|
}
|
|
}
|
|
for _, src := range compiler.Properties.Srcs {
|
|
if filepath.Ext(src) == ext {
|
|
return true
|
|
}
|
|
}
|
|
for _, src := range compiler.Properties.OriginalSrcs {
|
|
if filepath.Ext(src) == ext {
|
|
return true
|
|
}
|
|
}
|
|
|
|
return false
|
|
}
|
|
|
|
func (compiler *baseCompiler) uniqueApexVariations() bool {
|
|
return compiler.useApexNameMacro()
|
|
}
|
|
|
|
var invalidDefineCharRegex = regexp.MustCompile("[^a-zA-Z0-9_]")
|
|
|
|
// makeDefineString transforms a name of an APEX module into a value to be used as value for C define
|
|
// For example, com.android.foo => COM_ANDROID_FOO
|
|
func makeDefineString(name string) string {
|
|
return invalidDefineCharRegex.ReplaceAllString(strings.ToUpper(name), "_")
|
|
}
|
|
|
|
var gnuToCReplacer = strings.NewReplacer("gnu", "c")
|
|
|
|
func ndkPathDeps(ctx ModuleContext) android.Paths {
|
|
if ctx.Module().(*Module).IsSdkVariant() {
|
|
// The NDK sysroot timestamp file depends on all the NDK sysroot files
|
|
// (headers and libraries).
|
|
return android.Paths{getNdkBaseTimestampFile(ctx)}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (compiler *baseCompiler) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects {
|
|
pathDeps := deps.GeneratedDeps
|
|
pathDeps = append(pathDeps, ndkPathDeps(ctx)...)
|
|
|
|
buildFlags := flagsToBuilderFlags(flags)
|
|
|
|
srcs := append(android.Paths(nil), compiler.srcsBeforeGen...)
|
|
|
|
srcs, genDeps, info := genSources(ctx, srcs, buildFlags)
|
|
pathDeps = append(pathDeps, genDeps...)
|
|
|
|
compiler.pathDeps = pathDeps
|
|
compiler.generatedSourceInfo = info
|
|
compiler.cFlagsDeps = flags.CFlagsDeps
|
|
|
|
// Save src, buildFlags and context
|
|
compiler.srcs = srcs
|
|
|
|
// Compile files listed in c.Properties.Srcs into objects
|
|
objs := compileObjs(ctx, buildFlags, "", srcs, pathDeps, compiler.cFlagsDeps)
|
|
|
|
if ctx.Failed() {
|
|
return Objects{}
|
|
}
|
|
|
|
return objs
|
|
}
|
|
|
|
// Compile a list of source files into objects a specified subdirectory
|
|
func compileObjs(ctx android.ModuleContext, flags builderFlags,
|
|
subdir string, srcFiles, pathDeps android.Paths, cFlagsDeps android.Paths) Objects {
|
|
|
|
return transformSourceToObj(ctx, subdir, srcFiles, flags, pathDeps, cFlagsDeps)
|
|
}
|
|
|
|
var thirdPartyDirPrefixExceptions = []*regexp.Regexp{
|
|
regexp.MustCompile("^vendor/[^/]*google[^/]*/"),
|
|
regexp.MustCompile("^hardware/google/"),
|
|
regexp.MustCompile("^hardware/interfaces/"),
|
|
regexp.MustCompile("^hardware/libhardware[^/]*/"),
|
|
regexp.MustCompile("^hardware/ril/"),
|
|
}
|
|
|
|
func isThirdParty(path string) bool {
|
|
thirdPartyDirPrefixes := []string{"external/", "vendor/", "hardware/"}
|
|
|
|
if android.HasAnyPrefix(path, thirdPartyDirPrefixes) {
|
|
for _, prefix := range thirdPartyDirPrefixExceptions {
|
|
if prefix.MatchString(path) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// Properties for rust_bindgen related to generating rust bindings.
|
|
// This exists here so these properties can be included in a cc_default
|
|
// which can be used in both cc and rust modules.
|
|
type RustBindgenClangProperties struct {
|
|
// list of directories relative to the Blueprints file that will
|
|
// be added to the include path using -I
|
|
Local_include_dirs []string `android:"arch_variant,variant_prepend"`
|
|
|
|
// list of static libraries that provide headers for this binding.
|
|
Static_libs []string `android:"arch_variant,variant_prepend"`
|
|
|
|
// list of shared libraries that provide headers for this binding.
|
|
Shared_libs []string `android:"arch_variant"`
|
|
|
|
// List of libraries which export include paths required for this module
|
|
Header_libs []string `android:"arch_variant,variant_prepend"`
|
|
|
|
// list of clang flags required to correctly interpret the headers.
|
|
Cflags []string `android:"arch_variant"`
|
|
|
|
// list of c++ specific clang flags required to correctly interpret the headers.
|
|
// This is provided primarily to make sure cppflags defined in cc_defaults are pulled in.
|
|
Cppflags []string `android:"arch_variant"`
|
|
|
|
// C standard version to use. Can be a specific version (such as "gnu11"),
|
|
// "experimental" (which will use draft versions like C1x when available),
|
|
// or the empty string (which will use the default).
|
|
//
|
|
// If this is set, the file extension will be ignored and this will be used as the std version value. Setting this
|
|
// to "default" will use the build system default version. This cannot be set at the same time as cpp_std.
|
|
C_std *string
|
|
|
|
// C++ standard version to use. Can be a specific version (such as
|
|
// "gnu++11"), "experimental" (which will use draft versions like C++1z when
|
|
// available), or the empty string (which will use the default).
|
|
//
|
|
// If this is set, the file extension will be ignored and this will be used as the std version value. Setting this
|
|
// to "default" will use the build system default version. This cannot be set at the same time as c_std.
|
|
Cpp_std *string
|
|
|
|
//TODO(b/161141999) Add support for headers from cc_library_header modules.
|
|
}
|