• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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	Lex  *LexProperties
115
116	Aidl struct {
117		// list of directories that will be added to the aidl include paths.
118		Include_dirs []string
119
120		// list of directories relative to the Blueprints file that will
121		// be added to the aidl include paths.
122		Local_include_dirs []string
123
124		// whether to generate traces (for systrace) for this interface
125		Generate_traces *bool
126
127		// list of flags that will be passed to the AIDL compiler
128		Flags []string
129	}
130
131	Renderscript struct {
132		// list of directories that will be added to the llvm-rs-cc include paths
133		Include_dirs []string
134
135		// list of flags that will be passed to llvm-rs-cc
136		Flags []string
137
138		// Renderscript API level to target
139		Target_api *string
140	}
141
142	Debug, Release struct {
143		// list of module-specific flags that will be used for C and C++ compiles in debug or
144		// release builds
145		Cflags []string `android:"arch_variant"`
146	} `android:"arch_variant"`
147
148	Target struct {
149		Vendor, Product struct {
150			// list of source files that should only be used in vendor or
151			// product variant of the C/C++ module.
152			Srcs []string `android:"path"`
153
154			// list of source files that should not be used to build vendor
155			// or product variant of the C/C++ module.
156			Exclude_srcs []string `android:"path"`
157
158			// List of additional cflags that should be used to build vendor
159			// or product variant of the C/C++ module.
160			Cflags []string
161
162			// list of generated sources that should not be used to build
163			// vendor or product variant of the C/C++ module.
164			Exclude_generated_sources []string
165		}
166		Recovery struct {
167			// list of source files that should only be used in the
168			// recovery variant of the C/C++ module.
169			Srcs []string `android:"path"`
170
171			// list of source files that should not be used to
172			// build the recovery variant of the C/C++ module.
173			Exclude_srcs []string `android:"path"`
174
175			// List of additional cflags that should be used to build the recovery
176			// variant of the C/C++ module.
177			Cflags []string
178
179			// list of generated sources that should not be used to
180			// build the recovery variant of the C/C++ module.
181			Exclude_generated_sources []string
182		}
183		Vendor_ramdisk struct {
184			// list of source files that should not be used to
185			// build the vendor ramdisk variant of the C/C++ module.
186			Exclude_srcs []string `android:"path"`
187
188			// List of additional cflags that should be used to build the vendor ramdisk
189			// variant of the C/C++ module.
190			Cflags []string
191		}
192	}
193
194	Proto struct {
195		// Link statically against the protobuf runtime
196		Static *bool `android:"arch_variant"`
197	} `android:"arch_variant"`
198
199	// Stores the original list of source files before being cleared by library reuse
200	OriginalSrcs []string `blueprint:"mutated"`
201
202	// Build and link with OpenMP
203	Openmp *bool `android:"arch_variant"`
204
205	// Deprecated.
206	// Adds __ANDROID_APEX_<APEX_MODULE_NAME>__ macro defined for apex variants in addition to __ANDROID_APEX__
207	Use_apex_name_macro *bool
208
209	// Adds two macros for apex variants in addition to __ANDROID_APEX__
210	// * __ANDROID_APEX_COM_ANDROID_FOO__
211	// * __ANDROID_APEX_NAME__="com.android.foo"
212	UseApexNameMacro bool `blueprint:"mutated"`
213}
214
215func NewBaseCompiler() *baseCompiler {
216	return &baseCompiler{}
217}
218
219type baseCompiler struct {
220	Properties BaseCompilerProperties
221	Proto      android.ProtoProperties
222	cFlagsDeps android.Paths
223	pathDeps   android.Paths
224	flags      builderFlags
225
226	// Sources that were passed to the C/C++ compiler
227	srcs android.Paths
228
229	// Sources that were passed in the Android.bp file, including generated sources generated by
230	// other modules and filegroups. May include source files that have not yet been translated to
231	// C/C++ (.aidl, .proto, etc.)
232	srcsBeforeGen android.Paths
233
234	generatedSourceInfo
235}
236
237var _ compiler = (*baseCompiler)(nil)
238
239type CompiledInterface interface {
240	Srcs() android.Paths
241}
242
243func (compiler *baseCompiler) Srcs() android.Paths {
244	return append(android.Paths{}, compiler.srcs...)
245}
246
247func (compiler *baseCompiler) appendCflags(flags []string) {
248	compiler.Properties.Cflags = append(compiler.Properties.Cflags, flags...)
249}
250
251func (compiler *baseCompiler) appendAsflags(flags []string) {
252	compiler.Properties.Asflags = append(compiler.Properties.Asflags, flags...)
253}
254
255func (compiler *baseCompiler) compilerProps() []interface{} {
256	return []interface{}{&compiler.Properties, &compiler.Proto}
257}
258
259func (compiler *baseCompiler) includeBuildDirectory() bool {
260	return proptools.BoolDefault(compiler.Properties.Include_build_directory, true)
261}
262
263func (compiler *baseCompiler) compilerInit(ctx BaseModuleContext) {}
264
265func (compiler *baseCompiler) compilerDeps(ctx DepsContext, deps Deps) Deps {
266	deps.GeneratedSources = append(deps.GeneratedSources, compiler.Properties.Generated_sources...)
267	deps.GeneratedSources = removeListFromList(deps.GeneratedSources, compiler.Properties.Exclude_generated_sources)
268	deps.GeneratedHeaders = append(deps.GeneratedHeaders, compiler.Properties.Generated_headers...)
269
270	android.ProtoDeps(ctx, &compiler.Proto)
271	if compiler.hasSrcExt(".proto") {
272		deps = protoDeps(ctx, deps, &compiler.Proto, Bool(compiler.Properties.Proto.Static))
273	}
274
275	if Bool(compiler.Properties.Openmp) {
276		deps.StaticLibs = append(deps.StaticLibs, "libomp")
277	}
278
279	return deps
280}
281
282func (compiler *baseCompiler) useApexNameMacro() bool {
283	return Bool(compiler.Properties.Use_apex_name_macro) || compiler.Properties.UseApexNameMacro
284}
285
286// Return true if the module is in the WarningAllowedProjects.
287func warningsAreAllowed(subdir string) bool {
288	subdir += "/"
289	return android.HasAnyPrefix(subdir, config.WarningAllowedProjects)
290}
291
292func addToModuleList(ctx ModuleContext, key android.OnceKey, module string) {
293	getNamedMapForConfig(ctx.Config(), key).Store(module, true)
294}
295
296// Create a Flags struct that collects the compile flags from global values,
297// per-target values, module type values, and per-module Blueprints properties
298func (compiler *baseCompiler) compilerFlags(ctx ModuleContext, flags Flags, deps PathDeps) Flags {
299	tc := ctx.toolchain()
300	modulePath := android.PathForModuleSrc(ctx).String()
301
302	compiler.srcsBeforeGen = android.PathsForModuleSrcExcludes(ctx, compiler.Properties.Srcs, compiler.Properties.Exclude_srcs)
303	compiler.srcsBeforeGen = append(compiler.srcsBeforeGen, deps.GeneratedSources...)
304
305	CheckBadCompilerFlags(ctx, "cflags", compiler.Properties.Cflags)
306	CheckBadCompilerFlags(ctx, "cppflags", compiler.Properties.Cppflags)
307	CheckBadCompilerFlags(ctx, "conlyflags", compiler.Properties.Conlyflags)
308	CheckBadCompilerFlags(ctx, "asflags", compiler.Properties.Asflags)
309	CheckBadCompilerFlags(ctx, "vendor.cflags", compiler.Properties.Target.Vendor.Cflags)
310	CheckBadCompilerFlags(ctx, "product.cflags", compiler.Properties.Target.Product.Cflags)
311	CheckBadCompilerFlags(ctx, "recovery.cflags", compiler.Properties.Target.Recovery.Cflags)
312	CheckBadCompilerFlags(ctx, "vendor_ramdisk.cflags", compiler.Properties.Target.Vendor_ramdisk.Cflags)
313
314	esc := proptools.NinjaAndShellEscapeList
315
316	flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Cflags)...)
317	flags.Local.CppFlags = append(flags.Local.CppFlags, esc(compiler.Properties.Cppflags)...)
318	flags.Local.ConlyFlags = append(flags.Local.ConlyFlags, esc(compiler.Properties.Conlyflags)...)
319	flags.Local.AsFlags = append(flags.Local.AsFlags, esc(compiler.Properties.Asflags)...)
320	flags.Local.YasmFlags = append(flags.Local.YasmFlags, esc(compiler.Properties.Asflags)...)
321
322	flags.Yacc = compiler.Properties.Yacc
323	flags.Lex = compiler.Properties.Lex
324
325	// Include dir cflags
326	localIncludeDirs := android.PathsForModuleSrc(ctx, compiler.Properties.Local_include_dirs)
327	if len(localIncludeDirs) > 0 {
328		f := includeDirsToFlags(localIncludeDirs)
329		flags.Local.CommonFlags = append(flags.Local.CommonFlags, f)
330		flags.Local.YasmFlags = append(flags.Local.YasmFlags, f)
331	}
332	rootIncludeDirs := android.PathsForSource(ctx, compiler.Properties.Include_dirs)
333	if len(rootIncludeDirs) > 0 {
334		f := includeDirsToFlags(rootIncludeDirs)
335		flags.Local.CommonFlags = append(flags.Local.CommonFlags, f)
336		flags.Local.YasmFlags = append(flags.Local.YasmFlags, f)
337	}
338
339	if compiler.includeBuildDirectory() {
340		flags.Local.CommonFlags = append(flags.Local.CommonFlags, "-I"+modulePath)
341		flags.Local.YasmFlags = append(flags.Local.YasmFlags, "-I"+modulePath)
342	}
343
344	if !(ctx.useSdk() || ctx.useVndk()) || ctx.Host() {
345		flags.SystemIncludeFlags = append(flags.SystemIncludeFlags,
346			"${config.CommonGlobalIncludes}",
347			tc.IncludeFlags())
348	}
349
350	if ctx.useSdk() {
351		// TODO: Switch to --sysroot.
352		// The NDK headers are installed to a common sysroot. While a more
353		// typical Soong approach would be to only make the headers for the
354		// library you're using available, we're trying to emulate the NDK
355		// behavior here, and the NDK always has all the NDK headers available.
356		flags.SystemIncludeFlags = append(flags.SystemIncludeFlags,
357			"-isystem "+getCurrentIncludePath(ctx).String(),
358			"-isystem "+getCurrentIncludePath(ctx).Join(ctx, config.NDKTriple(tc)).String())
359	}
360
361	if ctx.useVndk() {
362		flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_VNDK__")
363		if ctx.inVendor() {
364			flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_VENDOR__")
365		} else if ctx.inProduct() {
366			flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_PRODUCT__")
367		}
368	}
369
370	if ctx.inRecovery() {
371		flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_RECOVERY__")
372	}
373
374	if ctx.apexVariationName() != "" {
375		flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_APEX__")
376		if compiler.useApexNameMacro() {
377			flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_APEX_"+makeDefineString(ctx.apexVariationName())+"__")
378			flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_APEX_NAME__='\""+ctx.apexVariationName()+"\"'")
379		}
380		if ctx.Device() {
381			flags.Global.CommonFlags = append(flags.Global.CommonFlags,
382				fmt.Sprintf("-D__ANDROID_APEX_MIN_SDK_VERSION__=%d",
383					ctx.apexSdkVersion().FinalOrFutureInt()))
384		}
385	}
386
387	if ctx.Target().NativeBridge == android.NativeBridgeEnabled {
388		flags.Global.CommonFlags = append(flags.Global.CommonFlags, "-D__ANDROID_NATIVE_BRIDGE__")
389	}
390
391	instructionSet := String(compiler.Properties.Instruction_set)
392	if flags.RequiredInstructionSet != "" {
393		instructionSet = flags.RequiredInstructionSet
394	}
395	instructionSetFlags, err := tc.ClangInstructionSetFlags(instructionSet)
396	if err != nil {
397		ctx.ModuleErrorf("%s", err)
398	}
399
400	CheckBadCompilerFlags(ctx, "release.cflags", compiler.Properties.Release.Cflags)
401
402	// TODO: debug
403	flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Release.Cflags)...)
404
405	CheckBadCompilerFlags(ctx, "clang_cflags", compiler.Properties.Clang_cflags)
406	CheckBadCompilerFlags(ctx, "clang_asflags", compiler.Properties.Clang_asflags)
407
408	flags.Local.CFlags = config.ClangFilterUnknownCflags(flags.Local.CFlags)
409	flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Clang_cflags)...)
410	flags.Local.AsFlags = append(flags.Local.AsFlags, esc(compiler.Properties.Clang_asflags)...)
411	flags.Local.CppFlags = config.ClangFilterUnknownCflags(flags.Local.CppFlags)
412	flags.Local.ConlyFlags = config.ClangFilterUnknownCflags(flags.Local.ConlyFlags)
413	flags.Local.LdFlags = config.ClangFilterUnknownCflags(flags.Local.LdFlags)
414
415	target := "-target " + tc.ClangTriple()
416	if ctx.Os().Class == android.Device {
417		version := ctx.minSdkVersion()
418		if version == "" || version == "current" {
419			target += strconv.Itoa(android.FutureApiLevelInt)
420		} else {
421			target += version
422		}
423	}
424
425	gccPrefix := "-B" + config.ToolPath(tc)
426
427	flags.Global.CFlags = append(flags.Global.CFlags, target, gccPrefix)
428	flags.Global.AsFlags = append(flags.Global.AsFlags, target, gccPrefix)
429	flags.Global.LdFlags = append(flags.Global.LdFlags, target, gccPrefix)
430
431	hod := "Host"
432	if ctx.Os().Class == android.Device {
433		hod = "Device"
434	}
435
436	flags.Global.CommonFlags = append(flags.Global.CommonFlags, instructionSetFlags)
437	flags.Global.ConlyFlags = append([]string{"${config.CommonGlobalConlyflags}"}, flags.Global.ConlyFlags...)
438	flags.Global.CppFlags = append([]string{fmt.Sprintf("${config.%sGlobalCppflags}", hod)}, flags.Global.CppFlags...)
439
440	flags.Global.AsFlags = append(flags.Global.AsFlags, tc.ClangAsflags())
441	flags.Global.CppFlags = append([]string{"${config.CommonClangGlobalCppflags}"}, flags.Global.CppFlags...)
442	flags.Global.CommonFlags = append(flags.Global.CommonFlags,
443		tc.ClangCflags(),
444		"${config.CommonClangGlobalCflags}",
445		fmt.Sprintf("${config.%sClangGlobalCflags}", hod))
446
447	if isThirdParty(modulePath) {
448		flags.Global.CommonFlags = append(flags.Global.CommonFlags, "${config.ClangExternalCflags}")
449	}
450
451	if tc.Bionic() {
452		if Bool(compiler.Properties.Rtti) {
453			flags.Local.CppFlags = append(flags.Local.CppFlags, "-frtti")
454		} else {
455			flags.Local.CppFlags = append(flags.Local.CppFlags, "-fno-rtti")
456		}
457	}
458
459	flags.Global.AsFlags = append(flags.Global.AsFlags, "-D__ASSEMBLY__")
460
461	flags.Global.CppFlags = append(flags.Global.CppFlags, tc.ClangCppflags())
462
463	flags.Global.YasmFlags = append(flags.Global.YasmFlags, tc.YasmFlags())
464
465	flags.Global.CommonFlags = append(flags.Global.CommonFlags, tc.ToolchainClangCflags())
466
467	cStd := config.CStdVersion
468	if String(compiler.Properties.C_std) == "experimental" {
469		cStd = config.ExperimentalCStdVersion
470	} else if String(compiler.Properties.C_std) != "" {
471		cStd = String(compiler.Properties.C_std)
472	}
473
474	cppStd := String(compiler.Properties.Cpp_std)
475	switch String(compiler.Properties.Cpp_std) {
476	case "":
477		cppStd = config.CppStdVersion
478	case "experimental":
479		cppStd = config.ExperimentalCppStdVersion
480	}
481
482	if compiler.Properties.Gnu_extensions != nil && *compiler.Properties.Gnu_extensions == false {
483		cStd = gnuToCReplacer.Replace(cStd)
484		cppStd = gnuToCReplacer.Replace(cppStd)
485	}
486
487	flags.Local.ConlyFlags = append([]string{"-std=" + cStd}, flags.Local.ConlyFlags...)
488	flags.Local.CppFlags = append([]string{"-std=" + cppStd}, flags.Local.CppFlags...)
489
490	if ctx.inVendor() {
491		flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Vendor.Cflags)...)
492	}
493
494	if ctx.inProduct() {
495		flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Product.Cflags)...)
496	}
497
498	if ctx.inRecovery() {
499		flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Recovery.Cflags)...)
500	}
501
502	if ctx.inVendorRamdisk() {
503		flags.Local.CFlags = append(flags.Local.CFlags, esc(compiler.Properties.Target.Vendor_ramdisk.Cflags)...)
504	}
505
506	// We can enforce some rules more strictly in the code we own. strict
507	// indicates if this is code that we can be stricter with. If we have
508	// rules that we want to apply to *our* code (but maybe can't for
509	// vendor/device specific things), we could extend this to be a ternary
510	// value.
511	strict := true
512	if strings.HasPrefix(modulePath, "external/") {
513		strict = false
514	}
515
516	// Can be used to make some annotations stricter for code we can fix
517	// (such as when we mark functions as deprecated).
518	if strict {
519		flags.Global.CFlags = append(flags.Global.CFlags, "-DANDROID_STRICT")
520	}
521
522	if compiler.hasSrcExt(".proto") {
523		flags = protoFlags(ctx, flags, &compiler.Proto)
524	}
525
526	if compiler.hasSrcExt(".y") || compiler.hasSrcExt(".yy") {
527		flags.Local.CommonFlags = append(flags.Local.CommonFlags,
528			"-I"+android.PathForModuleGen(ctx, "yacc", ctx.ModuleDir()).String())
529	}
530
531	if compiler.hasSrcExt(".mc") {
532		flags.Local.CommonFlags = append(flags.Local.CommonFlags,
533			"-I"+android.PathForModuleGen(ctx, "windmc", ctx.ModuleDir()).String())
534	}
535
536	if compiler.hasSrcExt(".aidl") {
537		flags.aidlFlags = append(flags.aidlFlags, compiler.Properties.Aidl.Flags...)
538		if len(compiler.Properties.Aidl.Local_include_dirs) > 0 {
539			localAidlIncludeDirs := android.PathsForModuleSrc(ctx, compiler.Properties.Aidl.Local_include_dirs)
540			flags.aidlFlags = append(flags.aidlFlags, includeDirsToFlags(localAidlIncludeDirs))
541		}
542		if len(compiler.Properties.Aidl.Include_dirs) > 0 {
543			rootAidlIncludeDirs := android.PathsForSource(ctx, compiler.Properties.Aidl.Include_dirs)
544			flags.aidlFlags = append(flags.aidlFlags, includeDirsToFlags(rootAidlIncludeDirs))
545		}
546
547		if Bool(compiler.Properties.Aidl.Generate_traces) {
548			flags.aidlFlags = append(flags.aidlFlags, "-t")
549		}
550
551		flags.Local.CommonFlags = append(flags.Local.CommonFlags,
552			"-I"+android.PathForModuleGen(ctx, "aidl").String())
553	}
554
555	if compiler.hasSrcExt(".rscript") || compiler.hasSrcExt(".fs") {
556		flags = rsFlags(ctx, flags, &compiler.Properties)
557	}
558
559	if compiler.hasSrcExt(".sysprop") {
560		flags.Local.CommonFlags = append(flags.Local.CommonFlags,
561			"-I"+android.PathForModuleGen(ctx, "sysprop", "include").String())
562	}
563
564	if len(compiler.Properties.Srcs) > 0 {
565		module := ctx.ModuleDir() + "/Android.bp:" + ctx.ModuleName()
566		if inList("-Wno-error", flags.Local.CFlags) || inList("-Wno-error", flags.Local.CppFlags) {
567			addToModuleList(ctx, modulesUsingWnoErrorKey, module)
568		} else if !inList("-Werror", flags.Local.CFlags) && !inList("-Werror", flags.Local.CppFlags) {
569			if warningsAreAllowed(ctx.ModuleDir()) {
570				addToModuleList(ctx, modulesAddedWallKey, module)
571				flags.Local.CFlags = append([]string{"-Wall"}, flags.Local.CFlags...)
572			} else {
573				flags.Local.CFlags = append([]string{"-Wall", "-Werror"}, flags.Local.CFlags...)
574			}
575		}
576	}
577
578	if Bool(compiler.Properties.Openmp) {
579		flags.Local.CFlags = append(flags.Local.CFlags, "-fopenmp")
580	}
581
582	// Exclude directories from manual binder interface allowed list.
583	//TODO(b/145621474): Move this check into IInterface.h when clang-tidy no longer uses absolute paths.
584	if android.HasAnyPrefix(ctx.ModuleDir(), allowedManualInterfacePaths) {
585		flags.Local.CFlags = append(flags.Local.CFlags, "-DDO_NOT_CHECK_MANUAL_BINDER_INTERFACES")
586	}
587
588	return flags
589}
590
591func (compiler *baseCompiler) hasSrcExt(ext string) bool {
592	for _, src := range compiler.srcsBeforeGen {
593		if src.Ext() == ext {
594			return true
595		}
596	}
597	for _, src := range compiler.Properties.Srcs {
598		if filepath.Ext(src) == ext {
599			return true
600		}
601	}
602	for _, src := range compiler.Properties.OriginalSrcs {
603		if filepath.Ext(src) == ext {
604			return true
605		}
606	}
607
608	return false
609}
610
611func (compiler *baseCompiler) uniqueApexVariations() bool {
612	return compiler.useApexNameMacro()
613}
614
615var invalidDefineCharRegex = regexp.MustCompile("[^a-zA-Z0-9_]")
616
617// makeDefineString transforms a name of an APEX module into a value to be used as value for C define
618// For example, com.android.foo => COM_ANDROID_FOO
619func makeDefineString(name string) string {
620	return invalidDefineCharRegex.ReplaceAllString(strings.ToUpper(name), "_")
621}
622
623var gnuToCReplacer = strings.NewReplacer("gnu", "c")
624
625func ndkPathDeps(ctx ModuleContext) android.Paths {
626	if ctx.Module().(*Module).IsSdkVariant() {
627		// The NDK sysroot timestamp file depends on all the NDK sysroot files
628		// (headers and libraries).
629		return android.Paths{getNdkBaseTimestampFile(ctx)}
630	}
631	return nil
632}
633
634func (compiler *baseCompiler) compile(ctx ModuleContext, flags Flags, deps PathDeps) Objects {
635	pathDeps := deps.GeneratedDeps
636	pathDeps = append(pathDeps, ndkPathDeps(ctx)...)
637
638	buildFlags := flagsToBuilderFlags(flags)
639
640	srcs := append(android.Paths(nil), compiler.srcsBeforeGen...)
641
642	srcs, genDeps, info := genSources(ctx, srcs, buildFlags)
643	pathDeps = append(pathDeps, genDeps...)
644
645	compiler.pathDeps = pathDeps
646	compiler.generatedSourceInfo = info
647	compiler.cFlagsDeps = flags.CFlagsDeps
648
649	// Save src, buildFlags and context
650	compiler.srcs = srcs
651
652	// Compile files listed in c.Properties.Srcs into objects
653	objs := compileObjs(ctx, buildFlags, "", srcs, pathDeps, compiler.cFlagsDeps)
654
655	if ctx.Failed() {
656		return Objects{}
657	}
658
659	return objs
660}
661
662// Compile a list of source files into objects a specified subdirectory
663func compileObjs(ctx android.ModuleContext, flags builderFlags,
664	subdir string, srcFiles, pathDeps android.Paths, cFlagsDeps android.Paths) Objects {
665
666	return transformSourceToObj(ctx, subdir, srcFiles, flags, pathDeps, cFlagsDeps)
667}
668
669var thirdPartyDirPrefixExceptions = []*regexp.Regexp{
670	regexp.MustCompile("^vendor/[^/]*google[^/]*/"),
671	regexp.MustCompile("^hardware/google/"),
672	regexp.MustCompile("^hardware/interfaces/"),
673	regexp.MustCompile("^hardware/libhardware[^/]*/"),
674	regexp.MustCompile("^hardware/ril/"),
675}
676
677func isThirdParty(path string) bool {
678	thirdPartyDirPrefixes := []string{"external/", "vendor/", "hardware/"}
679
680	if android.HasAnyPrefix(path, thirdPartyDirPrefixes) {
681		for _, prefix := range thirdPartyDirPrefixExceptions {
682			if prefix.MatchString(path) {
683				return false
684			}
685		}
686	}
687	return true
688}
689
690// Properties for rust_bindgen related to generating rust bindings.
691// This exists here so these properties can be included in a cc_default
692// which can be used in both cc and rust modules.
693type RustBindgenClangProperties struct {
694	// list of directories relative to the Blueprints file that will
695	// be added to the include path using -I
696	Local_include_dirs []string `android:"arch_variant,variant_prepend"`
697
698	// list of static libraries that provide headers for this binding.
699	Static_libs []string `android:"arch_variant,variant_prepend"`
700
701	// list of shared libraries that provide headers for this binding.
702	Shared_libs []string `android:"arch_variant"`
703
704	// List of libraries which export include paths required for this module
705	Header_libs []string `android:"arch_variant,variant_prepend"`
706
707	// list of clang flags required to correctly interpret the headers.
708	Cflags []string `android:"arch_variant"`
709
710	// list of c++ specific clang flags required to correctly interpret the headers.
711	// This is provided primarily to make sure cppflags defined in cc_defaults are pulled in.
712	Cppflags []string `android:"arch_variant"`
713
714	// C standard version to use. Can be a specific version (such as "gnu11"),
715	// "experimental" (which will use draft versions like C1x when available),
716	// or the empty string (which will use the default).
717	//
718	// If this is set, the file extension will be ignored and this will be used as the std version value. Setting this
719	// to "default" will use the build system default version. This cannot be set at the same time as cpp_std.
720	C_std *string
721
722	// C++ standard version to use. Can be a specific version (such as
723	// "gnu++11"), "experimental" (which will use draft versions like C++1z when
724	// available), or the empty string (which will use the default).
725	//
726	// If this is set, the file extension will be ignored and this will be used as the std version value. Setting this
727	// to "default" will use the build system default version. This cannot be set at the same time as c_std.
728	Cpp_std *string
729
730	//TODO(b/161141999) Add support for headers from cc_library_header modules.
731}
732