1// Copyright 2016 Google Inc. All rights reserved. 2// 3// Licensed under the Apache License, Version 2.0 (the "License"); 4// you may not use this file except in compliance with the License. 5// You may obtain a copy of the License at 6// 7// http://www.apache.org/licenses/LICENSE-2.0 8// 9// Unless required by applicable law or agreed to in writing, software 10// distributed under the License is distributed on an "AS IS" BASIS, 11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12// See the License for the specific language governing permissions and 13// limitations under the License. 14 15package cc 16 17import ( 18 "fmt" 19 "path/filepath" 20 "regexp" 21 "strconv" 22 "strings" 23 24 "github.com/google/blueprint/proptools" 25 26 "android/soong/android" 27 "android/soong/cc/config" 28) 29 30var ( 31 allowedManualInterfacePaths = []string{"vendor/", "hardware/"} 32) 33 34// This file contains the basic C/C++/assembly to .o compliation steps 35 36type BaseCompilerProperties struct { 37 // list of source files used to compile the C/C++ module. May be .c, .cpp, or .S files. 38 // srcs may reference the outputs of other modules that produce source files like genrule 39 // or filegroup using the syntax ":module". 40 Srcs []string `android:"path,arch_variant"` 41 42 // list of source files that should not be used to build the C/C++ module. 43 // This is most useful in the arch/multilib variants to remove non-common files 44 Exclude_srcs []string `android:"path,arch_variant"` 45 46 // list of module-specific flags that will be used for C and C++ compiles. 47 Cflags []string `android:"arch_variant"` 48 49 // list of module-specific flags that will be used for C++ compiles 50 Cppflags []string `android:"arch_variant"` 51 52 // list of module-specific flags that will be used for C compiles 53 Conlyflags []string `android:"arch_variant"` 54 55 // list of module-specific flags that will be used for .S compiles 56 Asflags []string `android:"arch_variant"` 57 58 // list of module-specific flags that will be used for C and C++ compiles when 59 // compiling with clang 60 Clang_cflags []string `android:"arch_variant"` 61 62 // list of module-specific flags that will be used for .S compiles when 63 // compiling with clang 64 Clang_asflags []string `android:"arch_variant"` 65 66 // the instruction set architecture to use to compile the C/C++ 67 // module. 68 Instruction_set *string `android:"arch_variant"` 69 70 // list of directories relative to the root of the source tree that will 71 // be added to the include path using -I. 72 // If possible, don't use this. If adding paths from the current directory use 73 // local_include_dirs, if adding paths from other modules use export_include_dirs in 74 // that module. 75 Include_dirs []string `android:"arch_variant,variant_prepend"` 76 77 // list of directories relative to the Blueprints file that will 78 // be added to the include path using -I 79 Local_include_dirs []string `android:"arch_variant,variant_prepend"` 80 81 // Add the directory containing the Android.bp file to the list of include 82 // directories. Defaults to true. 83 Include_build_directory *bool 84 85 // list of generated sources to compile. These are the names of gensrcs or 86 // genrule modules. 87 Generated_sources []string `android:"arch_variant"` 88 89 // list of generated sources that should not be used to build the C/C++ module. 90 // This is most useful in the arch/multilib variants to remove non-common files 91 Exclude_generated_sources []string `android:"arch_variant"` 92 93 // list of generated headers to add to the include path. These are the names 94 // of genrule modules. 95 Generated_headers []string `android:"arch_variant"` 96 97 // pass -frtti instead of -fno-rtti 98 Rtti *bool 99 100 // C standard version to use. Can be a specific version (such as "gnu11"), 101 // "experimental" (which will use draft versions like C1x when available), 102 // or the empty string (which will use the default). 103 C_std *string 104 105 // C++ standard version to use. Can be a specific version (such as 106 // "gnu++11"), "experimental" (which will use draft versions like C++1z when 107 // available), or the empty string (which will use the default). 108 Cpp_std *string 109 110 // if set to false, use -std=c++* instead of -std=gnu++* 111 Gnu_extensions *bool 112 113 Yacc *YaccProperties 114 115 Aidl struct { 116 // list of directories that will be added to the aidl include paths. 117 Include_dirs []string 118 119 // list of directories relative to the Blueprints file that will 120 // be added to the aidl include paths. 121 Local_include_dirs []string 122 123 // whether to generate traces (for systrace) for this interface 124 Generate_traces *bool 125 } 126 127 Renderscript struct { 128 // list of directories that will be added to the llvm-rs-cc include paths 129 Include_dirs []string 130 131 // list of flags that will be passed to llvm-rs-cc 132 Flags []string 133 134 // Renderscript API level to target 135 Target_api *string 136 } 137 138 Debug, Release struct { 139 // list of module-specific flags that will be used for C and C++ compiles in debug or 140 // release builds 141 Cflags []string `android:"arch_variant"` 142 } `android:"arch_variant"` 143 144 Target struct { 145 Vendor struct { 146 // list of source files that should only be used in the 147 // vendor variant of the C/C++ module. 148 Srcs []string `android:"path"` 149 150 // list of source files that should not be used to 151 // build the vendor variant of the C/C++ module. 152 Exclude_srcs []string `android:"path"` 153 154 // List of additional cflags that should be used to build the vendor 155 // variant of the C/C++ module. 156 Cflags []string 157 158 // list of generated sources that should not be used to 159 // build the vendor variant of the C/C++ module. 160 Exclude_generated_sources []string 161 } 162 Recovery struct { 163 // list of source files that should only be used in the 164 // recovery variant of the C/C++ module. 165 Srcs []string `android:"path"` 166 167 // list of source files that should not be used to 168 // build the recovery variant of the C/C++ module. 169 Exclude_srcs []string `android:"path"` 170 171 // List of additional cflags that should be used to build the recovery 172 // variant of the C/C++ module. 173 Cflags []string 174 175 // list of generated sources that should not be used to 176 // build the recovery variant of the C/C++ module. 177 Exclude_generated_sources []string 178 } 179 } 180 181 Proto struct { 182 // Link statically against the protobuf runtime 183 Static *bool `android:"arch_variant"` 184 } `android:"arch_variant"` 185 186 // Stores the original list of source files before being cleared by library reuse 187 OriginalSrcs []string `blueprint:"mutated"` 188 189 // Build and link with OpenMP 190 Openmp *bool `android:"arch_variant"` 191 192 // Adds __ANDROID_APEX_<APEX_MODULE_NAME>__ macro defined for apex variants in addition to __ANDROID_APEX__ 193 Use_apex_name_macro *bool 194} 195 196func NewBaseCompiler() *baseCompiler { 197 return &baseCompiler{} 198} 199 200type baseCompiler struct { 201 Properties BaseCompilerProperties 202 Proto android.ProtoProperties 203 cFlagsDeps android.Paths 204 pathDeps android.Paths 205 flags builderFlags 206 207 // Sources that were passed to the C/C++ compiler 208 srcs android.Paths 209 210 // Sources that were passed in the Android.bp file, including generated sources generated by 211 // other modules and filegroups. May include source files that have not yet been translated to 212 // C/C++ (.aidl, .proto, etc.) 213 srcsBeforeGen android.Paths 214} 215 216var _ compiler = (*baseCompiler)(nil) 217 218type CompiledInterface interface { 219 Srcs() android.Paths 220} 221 222func (compiler *baseCompiler) Srcs() android.Paths { 223 return append(android.Paths{}, compiler.srcs...) 224} 225 226func (compiler *baseCompiler) appendCflags(flags []string) { 227 compiler.Properties.Cflags = append(compiler.Properties.Cflags, flags...) 228} 229 230func (compiler *baseCompiler) appendAsflags(flags []string) { 231 compiler.Properties.Asflags = append(compiler.Properties.Asflags, flags...) 232} 233 234func (compiler *baseCompiler) compilerProps() []interface{} { 235 return []interface{}{&compiler.Properties, &compiler.Proto} 236} 237 238func (compiler *baseCompiler) compilerInit(ctx BaseModuleContext) {} 239 240func (compiler *baseCompiler) compilerDeps(ctx DepsContext, deps Deps) Deps { 241 deps.GeneratedSources = append(deps.GeneratedSources, compiler.Properties.Generated_sources...) 242 deps.GeneratedSources = removeListFromList(deps.GeneratedSources, compiler.Properties.Exclude_generated_sources) 243 deps.GeneratedHeaders = append(deps.GeneratedHeaders, compiler.Properties.Generated_headers...) 244 245 android.ProtoDeps(ctx, &compiler.Proto) 246 if compiler.hasSrcExt(".proto") { 247 deps = protoDeps(ctx, deps, &compiler.Proto, Bool(compiler.Properties.Proto.Static)) 248 } 249 250 if Bool(compiler.Properties.Openmp) { 251 deps.StaticLibs = append(deps.StaticLibs, "libomp") 252 } 253 254 return deps 255} 256 257// Return true if the module is in the WarningAllowedProjects. 258func warningsAreAllowed(subdir string) bool { 259 subdir += "/" 260 return android.HasAnyPrefix(subdir, config.WarningAllowedProjects) 261} 262 263func addToModuleList(ctx ModuleContext, key android.OnceKey, module string) { 264 getNamedMapForConfig(ctx.Config(), key).Store(module, true) 265} 266 267// Create a Flags struct that collects the compile flags from global values, 268// per-target values, module type values, and per-module Blueprints properties 269func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags { 270 tc := ctx.toolchain() 271 modulePath := android.PathForModuleSrc(ctx).String() 272 273 compiler.srcsBeforeGen = android.PathsForModuleSrcExcludes(ctx, compiler.Properties.Srcs, compiler.Properties.Exclude_srcs) 274 compiler.srcsBeforeGen = append(compiler.srcsBeforeGen, deps.GeneratedSources...) 275 276 CheckBadCompilerFlags(ctx, "cflags", compiler.Properties.Cflags) 277 CheckBadCompilerFlags(ctx, "cppflags", compiler.Properties.Cppflags) 278 CheckBadCompilerFlags(ctx, "conlyflags", compiler.Properties.Conlyflags) 279 CheckBadCompilerFlags(ctx, "asflags", compiler.Properties.Asflags) 280 CheckBadCompilerFlags(ctx, "vendor.cflags", compiler.Properties.Target.Vendor.Cflags) 281 CheckBadCompilerFlags(ctx, "recovery.cflags", compiler.Properties.Target.Recovery.Cflags) 282 283 esc := proptools.NinjaAndShellEscapeList 284 285 flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Cflags)...) 286 flags.Local.CppFlags = append(flags.Local.CppFlags, esc(compiler.Properties.Cppflags)...) 287 flags.Local.ConlyFlags = append(flags.Local.ConlyFlags, esc(compiler.Properties.Conlyflags)...) 288 flags.Local.AsFlags = append(flags.Local.AsFlags, esc(compiler.Properties.Asflags)...) 289 flags.Local.YasmFlags = append(flags.Local.YasmFlags, esc(compiler.Properties.Asflags)...) 290 291 flags.Yacc = compiler.Properties.Yacc 292 293 // Include dir cflags 294 localIncludeDirs := android.PathsForModuleSrc(ctx, compiler.Properties.Local_include_dirs) 295 if len(localIncludeDirs) > 0 { 296 f := includeDirsToFlags(localIncludeDirs) 297 flags.Local.CommonFlags = append(flags.Local.CommonFlags, f) 298 flags.Local.YasmFlags = append(flags.Local.YasmFlags, f) 299 } 300 rootIncludeDirs := android.PathsForSource(ctx, compiler.Properties.Include_dirs) 301 if len(rootIncludeDirs) > 0 { 302 f := includeDirsToFlags(rootIncludeDirs) 303 flags.Local.CommonFlags = append(flags.Local.CommonFlags, f) 304 flags.Local.YasmFlags = append(flags.Local.YasmFlags, f) 305 } 306 307 if compiler.Properties.Include_build_directory == nil || 308 *compiler.Properties.Include_build_directory { 309 flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+modulePath) 310 flags.Local.YasmFlags = append(flags.Local.YasmFlags, "-I"+modulePath) 311 } 312 313 if !(ctx.useSdk() || ctx.useVndk()) || ctx.Host() { 314 flags.SystemIncludeFlags = append(flags.SystemIncludeFlags, 315 "${config.CommonGlobalIncludes}", 316 tc.IncludeFlags()) 317 } 318 319 if ctx.useSdk() { 320 // TODO: Switch to --sysroot. 321 // The NDK headers are installed to a common sysroot. While a more 322 // typical Soong approach would be to only make the headers for the 323 // library you're using available, we're trying to emulate the NDK 324 // behavior here, and the NDK always has all the NDK headers available. 325 flags.SystemIncludeFlags = append(flags.SystemIncludeFlags, 326 "-isystem "+getCurrentIncludePath(ctx).String(), 327 "-isystem "+getCurrentIncludePath(ctx).Join(ctx, config.NDKTriple(tc)).String()) 328 } 329 330 if ctx.useVndk() { 331 flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_VNDK__") 332 } 333 334 if ctx.inRecovery() { 335 flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_RECOVERY__") 336 } 337 338 if ctx.apexName() != "" { 339 flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_APEX__") 340 if Bool(compiler.Properties.Use_apex_name_macro) { 341 flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_APEX_"+makeDefineString(ctx.apexName())+"__") 342 } 343 if ctx.Device() { 344 flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_SDK_VERSION__="+strconv.Itoa(ctx.apexSdkVersion())) 345 } 346 } 347 348 instructionSet := String(compiler.Properties.Instruction_set) 349 if flags.RequiredInstructionSet != "" { 350 instructionSet = flags.RequiredInstructionSet 351 } 352 instructionSetFlags, err := tc.ClangInstructionSetFlags(instructionSet) 353 if err != nil { 354 ctx.ModuleErrorf("%s", err) 355 } 356 357 CheckBadCompilerFlags(ctx, "release.cflags", compiler.Properties.Release.Cflags) 358 359 // TODO: debug 360 flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Release.Cflags)...) 361 362 CheckBadCompilerFlags(ctx, "clang_cflags", compiler.Properties.Clang_cflags) 363 CheckBadCompilerFlags(ctx, "clang_asflags", compiler.Properties.Clang_asflags) 364 365 flags.Local.CFlags = config.ClangFilterUnknownCflags(flags.Local.CFlags) 366 flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Clang_cflags)...) 367 flags.Local.AsFlags = append(flags.Local.AsFlags, esc(compiler.Properties.Clang_asflags)...) 368 flags.Local.CppFlags = config.ClangFilterUnknownCflags(flags.Local.CppFlags) 369 flags.Local.ConlyFlags = config.ClangFilterUnknownCflags(flags.Local.ConlyFlags) 370 flags.Local.LdFlags = config.ClangFilterUnknownCflags(flags.Local.LdFlags) 371 372 target := "-target " + tc.ClangTriple() 373 if ctx.Os().Class == android.Device { 374 version := ctx.sdkVersion() 375 if version == "" || version == "current" { 376 target += strconv.Itoa(android.FutureApiLevel) 377 } else { 378 target += version 379 } 380 } 381 382 gccPrefix := "-B" + config.ToolPath(tc) 383 384 flags.Global.CFlags = append(flags.Global.CFlags, target, gccPrefix) 385 flags.Global.AsFlags = append(flags.Global.AsFlags, target, gccPrefix) 386 flags.Global.LdFlags = append(flags.Global.LdFlags, target, gccPrefix) 387 388 hod := "Host" 389 if ctx.Os().Class == android.Device { 390 hod = "Device" 391 } 392 393 flags.Global.CommonFlags = append(flags.Global.CommonFlags, instructionSetFlags) 394 flags.Global.ConlyFlags = append([]string{"${config.CommonGlobalConlyflags}"}, flags.Global.ConlyFlags...) 395 flags.Global.CppFlags = append([]string{fmt.Sprintf("${config.%sGlobalCppflags}", hod)}, flags.Global.CppFlags...) 396 397 flags.Global.AsFlags = append(flags.Global.AsFlags, tc.ClangAsflags()) 398 flags.Global.CppFlags = append([]string{"${config.CommonClangGlobalCppflags}"}, flags.Global.CppFlags...) 399 flags.Global.CommonFlags = append(flags.Global.CommonFlags, 400 tc.ClangCflags(), 401 "${config.CommonClangGlobalCflags}", 402 fmt.Sprintf("${config.%sClangGlobalCflags}", hod)) 403 404 if isThirdParty(modulePath) { 405 flags.Global.CommonFlags = append([]string{"${config.ClangExternalCflags}"}, flags.Global.CommonFlags...) 406 } 407 408 if tc.Bionic() { 409 if Bool(compiler.Properties.Rtti) { 410 flags.Local.CppFlags = append(flags.Local.CppFlags, "-frtti") 411 } else { 412 flags.Local.CppFlags = append(flags.Local.CppFlags, "-fno-rtti") 413 } 414 } 415 416 flags.Global.AsFlags = append(flags.Global.AsFlags, "-D__ASSEMBLY__") 417 418 flags.Global.CppFlags = append(flags.Global.CppFlags, tc.ClangCppflags()) 419 420 flags.Global.YasmFlags = append(flags.Global.YasmFlags, tc.YasmFlags()) 421 422 flags.Global.CommonFlags = append(flags.Global.CommonFlags, tc.ToolchainClangCflags()) 423 424 cStd := config.CStdVersion 425 if String(compiler.Properties.C_std) == "experimental" { 426 cStd = config.ExperimentalCStdVersion 427 } else if String(compiler.Properties.C_std) != "" { 428 cStd = String(compiler.Properties.C_std) 429 } 430 431 cppStd := String(compiler.Properties.Cpp_std) 432 switch String(compiler.Properties.Cpp_std) { 433 case "": 434 cppStd = config.CppStdVersion 435 case "experimental": 436 cppStd = config.ExperimentalCppStdVersion 437 } 438 439 if compiler.Properties.Gnu_extensions != nil && *compiler.Properties.Gnu_extensions == false { 440 cStd = gnuToCReplacer.Replace(cStd) 441 cppStd = gnuToCReplacer.Replace(cppStd) 442 } 443 444 flags.Local.ConlyFlags = append([]string{"-std=" + cStd}, flags.Local.ConlyFlags...) 445 flags.Local.CppFlags = append([]string{"-std=" + cppStd}, flags.Local.CppFlags...) 446 447 if ctx.useVndk() { 448 flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Vendor.Cflags)...) 449 } 450 451 if ctx.inRecovery() { 452 flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Recovery.Cflags)...) 453 } 454 455 // We can enforce some rules more strictly in the code we own. strict 456 // indicates if this is code that we can be stricter with. If we have 457 // rules that we want to apply to *our* code (but maybe can't for 458 // vendor/device specific things), we could extend this to be a ternary 459 // value. 460 strict := true 461 if strings.HasPrefix(modulePath, "external/") { 462 strict = false 463 } 464 465 // Can be used to make some annotations stricter for code we can fix 466 // (such as when we mark functions as deprecated). 467 if strict { 468 flags.Global.CFlags = append(flags.Global.CFlags, "-DANDROID_STRICT") 469 } 470 471 if compiler.hasSrcExt(".proto") { 472 flags = protoFlags(ctx, flags, &compiler.Proto) 473 } 474 475 if compiler.hasSrcExt(".y") || compiler.hasSrcExt(".yy") { 476 flags.Local.CommonFlags = append(flags.Local.CommonFlags, 477 "-I"+android.PathForModuleGen(ctx, "yacc", ctx.ModuleDir()).String()) 478 } 479 480 if compiler.hasSrcExt(".mc") { 481 flags.Local.CommonFlags = append(flags.Local.CommonFlags, 482 "-I"+android.PathForModuleGen(ctx, "windmc", ctx.ModuleDir()).String()) 483 } 484 485 if compiler.hasSrcExt(".aidl") { 486 if len(compiler.Properties.Aidl.Local_include_dirs) > 0 { 487 localAidlIncludeDirs := android.PathsForModuleSrc(ctx, compiler.Properties.Aidl.Local_include_dirs) 488 flags.aidlFlags = append(flags.aidlFlags, includeDirsToFlags(localAidlIncludeDirs)) 489 } 490 if len(compiler.Properties.Aidl.Include_dirs) > 0 { 491 rootAidlIncludeDirs := android.PathsForSource(ctx, compiler.Properties.Aidl.Include_dirs) 492 flags.aidlFlags = append(flags.aidlFlags, includeDirsToFlags(rootAidlIncludeDirs)) 493 } 494 495 if Bool(compiler.Properties.Aidl.Generate_traces) { 496 flags.aidlFlags = append(flags.aidlFlags, "-t") 497 } 498 499 flags.Local.CommonFlags = append(flags.Local.CommonFlags, 500 "-I"+android.PathForModuleGen(ctx, "aidl").String()) 501 } 502 503 if compiler.hasSrcExt(".rscript") || compiler.hasSrcExt(".fs") { 504 flags = rsFlags(ctx, flags, &compiler.Properties) 505 } 506 507 if compiler.hasSrcExt(".sysprop") { 508 flags.Local.CommonFlags = append(flags.Local.CommonFlags, 509 "-I"+android.PathForModuleGen(ctx, "sysprop", "include").String()) 510 } 511 512 if len(compiler.Properties.Srcs) > 0 { 513 module := ctx.ModuleDir() + "/Android.bp:" + ctx.ModuleName() 514 if inList("-Wno-error", flags.Local.CFlags) || inList("-Wno-error", flags.Local.CppFlags) { 515 addToModuleList(ctx, modulesUsingWnoErrorKey, module) 516 } else if !inList("-Werror", flags.Local.CFlags) && !inList("-Werror", flags.Local.CppFlags) { 517 if warningsAreAllowed(ctx.ModuleDir()) { 518 addToModuleList(ctx, modulesAddedWallKey, module) 519 flags.Local.CFlags = append([]string{"-Wall"}, flags.Local.CFlags...) 520 } else { 521 flags.Local.CFlags = append([]string{"-Wall", "-Werror"}, flags.Local.CFlags...) 522 } 523 } 524 } 525 526 if Bool(compiler.Properties.Openmp) { 527 flags.Local.CFlags = append(flags.Local.CFlags, "-fopenmp") 528 } 529 530 // Exclude directories from manual binder interface allowed list. 531 //TODO(b/145621474): Move this check into IInterface.h when clang-tidy no longer uses absolute paths. 532 if android.HasAnyPrefix(ctx.ModuleDir(), allowedManualInterfacePaths) { 533 flags.Local.CFlags = append(flags.Local.CFlags, "-DDO_NOT_CHECK_MANUAL_BINDER_INTERFACES") 534 } 535 536 return flags 537} 538 539func (compiler *baseCompiler) hasSrcExt(ext string) bool { 540 for _, src := range compiler.srcsBeforeGen { 541 if src.Ext() == ext { 542 return true 543 } 544 } 545 for _, src := range compiler.Properties.Srcs { 546 if filepath.Ext(src) == ext { 547 return true 548 } 549 } 550 for _, src := range compiler.Properties.OriginalSrcs { 551 if filepath.Ext(src) == ext { 552 return true 553 } 554 } 555 556 return false 557} 558 559// makeDefineString transforms a name of an APEX module into a value to be used as value for C define 560// For example, com.android.foo => COM_ANDROID_FOO 561func makeDefineString(name string) string { 562 return strings.ReplaceAll(strings.ToUpper(name), ".", "_") 563} 564 565var gnuToCReplacer = strings.NewReplacer("gnu", "c") 566 567func ndkPathDeps(ctx ModuleContext) android.Paths { 568 if ctx.useSdk() { 569 // The NDK sysroot timestamp file depends on all the NDK sysroot files 570 // (headers and libraries). 571 return android.Paths{getNdkBaseTimestampFile(ctx)} 572 } 573 return nil 574} 575 576func (compiler *baseCompiler) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects { 577 pathDeps := deps.GeneratedDeps 578 pathDeps = append(pathDeps, ndkPathDeps(ctx)...) 579 580 buildFlags := flagsToBuilderFlags(flags) 581 582 srcs := append(android.Paths(nil), compiler.srcsBeforeGen...) 583 584 srcs, genDeps := genSources(ctx, srcs, buildFlags) 585 pathDeps = append(pathDeps, genDeps...) 586 587 compiler.pathDeps = pathDeps 588 compiler.cFlagsDeps = flags.CFlagsDeps 589 590 // Save src, buildFlags and context 591 compiler.srcs = srcs 592 593 // Compile files listed in c.Properties.Srcs into objects 594 objs := compileObjs(ctx, buildFlags, "", srcs, pathDeps, compiler.cFlagsDeps) 595 596 if ctx.Failed() { 597 return Objects{} 598 } 599 600 return objs 601} 602 603// Compile a list of source files into objects a specified subdirectory 604func compileObjs(ctx android.ModuleContext, flags builderFlags, 605 subdir string, srcFiles, pathDeps android.Paths, cFlagsDeps android.Paths) Objects { 606 607 return TransformSourceToObj(ctx, subdir, srcFiles, flags, pathDeps, cFlagsDeps) 608} 609 610var thirdPartyDirPrefixExceptions = []*regexp.Regexp{ 611 regexp.MustCompile("^vendor/[^/]*google[^/]*/"), 612 regexp.MustCompile("^hardware/google/"), 613 regexp.MustCompile("^hardware/interfaces/"), 614 regexp.MustCompile("^hardware/libhardware[^/]*/"), 615 regexp.MustCompile("^hardware/ril/"), 616} 617 618func isThirdParty(path string) bool { 619 thirdPartyDirPrefixes := []string{"external/", "vendor/", "hardware/"} 620 621 if android.HasAnyPrefix(path, thirdPartyDirPrefixes) { 622 for _, prefix := range thirdPartyDirPrefixExceptions { 623 if prefix.MatchString(path) { 624 return false 625 } 626 } 627 } 628 return true 629} 630