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