blob: 5ca5e5e0bb9e869c213a7410401907c5ec0180d8 [file] [log] [blame]
Colin Cross16b23492016-01-06 14:41:07 -08001// 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"
Colin Cross8ff9ef42017-05-08 13:44:11 -070019 "io"
Jeff Gaston72765392017-11-28 16:37:53 -080020 "sort"
Colin Cross16b23492016-01-06 14:41:07 -080021 "strings"
Vishwath Mohane7128792017-11-17 11:08:10 -080022 "sync"
Colin Cross16b23492016-01-06 14:41:07 -080023
Colin Cross6b753602018-06-21 13:03:07 -070024 "github.com/google/blueprint"
25
Colin Cross635c3b02016-05-18 15:37:25 -070026 "android/soong/android"
Evgenii Stepanovaf36db12016-08-15 14:18:24 -070027 "android/soong/cc/config"
Colin Cross16b23492016-01-06 14:41:07 -080028)
29
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -070030var (
31 // Any C flags added by sanitizer which libTooling tools may not
32 // understand also need to be added to ClangLibToolingUnknownCflags in
33 // cc/config/clang.go
Vishwath Mohanf3918d32017-02-14 07:59:33 -080034
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -070035 asanCflags = []string{"-fno-omit-frame-pointer"}
36 asanLdflags = []string{"-Wl,-u,__asan_preinit"}
37 asanLibs = []string{"libasan"}
38
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070039 hwasanCflags = []string{"-mllvm", "-hwasan-with-ifunc=0", "-fno-omit-frame-pointer", "-Wno-frame-larger-than="}
40
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000041 cfiCflags = []string{"-flto", "-fsanitize-cfi-cross-dso",
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -070042 "-fsanitize-blacklist=external/compiler-rt/lib/cfi/cfi_blacklist.txt"}
Evgenii Stepanovdbf1d4f2018-08-31 12:54:33 -070043 // -flto and -fvisibility are required by clang when -fsanitize=cfi is
44 // used, but have no effect on assembly files
45 cfiAsflags = []string{"-flto", "-fvisibility=default"}
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -070046 cfiLdflags = []string{"-flto", "-fsanitize-cfi-cross-dso", "-fsanitize=cfi",
Pirama Arumuga Nainarbdb17f02017-08-28 21:50:17 -070047 "-Wl,-plugin-opt,O1"}
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070048 cfiExportsMapPath = "build/soong/cc/config/cfi_exports.map"
49 cfiStaticLibsMutex sync.Mutex
50 hwasanStaticLibsMutex sync.Mutex
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -070051
Ivan Lozano30c5db22018-02-21 15:49:20 -080052 intOverflowCflags = []string{"-fsanitize-blacklist=build/soong/cc/config/integer_overflow_blacklist.txt"}
Ivan Lozanoae6ae1d2018-10-08 09:29:39 -070053 minimalRuntimeFlags = []string{"-fsanitize-minimal-runtime", "-fno-sanitize-trap=integer,undefined",
54 "-fno-sanitize-recover=integer,undefined"}
Evgenii Stepanov109029f2018-10-03 18:22:57 -070055 hwasanGlobalOptions = []string{"heap_history_size=4095"}
Dan Willemsencbceaab2016-10-13 16:44:07 -070056)
57
Colin Cross16b23492016-01-06 14:41:07 -080058type sanitizerType int
59
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070060func boolPtr(v bool) *bool {
61 if v {
62 return &v
63 } else {
64 return nil
65 }
66}
67
Colin Cross16b23492016-01-06 14:41:07 -080068const (
69 asan sanitizerType = iota + 1
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070070 hwasan
Colin Cross16b23492016-01-06 14:41:07 -080071 tsan
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -070072 intOverflow
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000073 cfi
Colin Cross16b23492016-01-06 14:41:07 -080074)
75
76func (t sanitizerType) String() string {
77 switch t {
78 case asan:
79 return "asan"
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070080 case hwasan:
81 return "hwasan"
Colin Cross16b23492016-01-06 14:41:07 -080082 case tsan:
83 return "tsan"
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -070084 case intOverflow:
85 return "intOverflow"
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000086 case cfi:
87 return "cfi"
Colin Cross16b23492016-01-06 14:41:07 -080088 default:
89 panic(fmt.Errorf("unknown sanitizerType %d", t))
90 }
91}
92
93type SanitizeProperties struct {
94 // enable AddressSanitizer, ThreadSanitizer, or UndefinedBehaviorSanitizer
95 Sanitize struct {
Nan Zhang0007d812017-11-07 10:57:05 -080096 Never *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080097
98 // main sanitizers
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070099 Address *bool `android:"arch_variant"`
100 Thread *bool `android:"arch_variant"`
101 Hwaddress *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -0800102
103 // local sanitizers
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700104 Undefined *bool `android:"arch_variant"`
105 All_undefined *bool `android:"arch_variant"`
106 Misc_undefined []string `android:"arch_variant"`
107 Coverage *bool `android:"arch_variant"`
108 Safestack *bool `android:"arch_variant"`
109 Cfi *bool `android:"arch_variant"`
110 Integer_overflow *bool `android:"arch_variant"`
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700111 Scudo *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -0800112
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700113 // Sanitizers to run in the diagnostic mode (as opposed to the release mode).
114 // Replaces abort() on error with a human-readable error message.
115 // Address and Thread sanitizers always run in diagnostic mode.
116 Diag struct {
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700117 Undefined *bool `android:"arch_variant"`
118 Cfi *bool `android:"arch_variant"`
119 Integer_overflow *bool `android:"arch_variant"`
120 Misc_undefined []string `android:"arch_variant"`
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700121 }
122
123 // value to pass to -fsanitize-recover=
Colin Cross16b23492016-01-06 14:41:07 -0800124 Recover []string
125
126 // value to pass to -fsanitize-blacklist
127 Blacklist *string
128 } `android:"arch_variant"`
129
Ivan Lozano30c5db22018-02-21 15:49:20 -0800130 SanitizerEnabled bool `blueprint:"mutated"`
131 SanitizeDep bool `blueprint:"mutated"`
132 MinimalRuntimeDep bool `blueprint:"mutated"`
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700133 UbsanRuntimeDep bool `blueprint:"mutated"`
Ivan Lozano30c5db22018-02-21 15:49:20 -0800134 InSanitizerDir bool `blueprint:"mutated"`
Colin Cross16b23492016-01-06 14:41:07 -0800135}
136
137type sanitize struct {
138 Properties SanitizeProperties
Colin Cross8ff9ef42017-05-08 13:44:11 -0700139
Jiyong Park27b188b2017-07-18 13:23:39 +0900140 runtimeLibrary string
141 androidMkRuntimeLibrary string
Colin Cross16b23492016-01-06 14:41:07 -0800142}
143
Vishwath Mohane7128792017-11-17 11:08:10 -0800144func init() {
145 android.RegisterMakeVarsProvider(pctx, cfiMakeVarsProvider)
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700146 android.RegisterMakeVarsProvider(pctx, hwasanMakeVarsProvider)
Vishwath Mohane7128792017-11-17 11:08:10 -0800147}
148
Colin Cross16b23492016-01-06 14:41:07 -0800149func (sanitize *sanitize) props() []interface{} {
150 return []interface{}{&sanitize.Properties}
151}
152
153func (sanitize *sanitize) begin(ctx BaseModuleContext) {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700154 s := &sanitize.Properties.Sanitize
155
Colin Cross16b23492016-01-06 14:41:07 -0800156 // Don't apply sanitizers to NDK code.
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700157 if ctx.useSdk() {
Nan Zhang0007d812017-11-07 10:57:05 -0800158 s.Never = BoolPtr(true)
Colin Cross16b23492016-01-06 14:41:07 -0800159 }
160
161 // Never always wins.
Nan Zhang0007d812017-11-07 10:57:05 -0800162 if Bool(s.Never) {
Colin Cross16b23492016-01-06 14:41:07 -0800163 return
164 }
165
Colin Cross16b23492016-01-06 14:41:07 -0800166 var globalSanitizers []string
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700167 var globalSanitizersDiag []string
168
Dan Willemsen8536d6b2018-10-07 20:54:34 -0700169 if ctx.Host() {
170 if !ctx.Windows() {
171 globalSanitizers = ctx.Config().SanitizeHost()
172 }
173 } else {
174 arches := ctx.Config().SanitizeDeviceArch()
175 if len(arches) == 0 || inList(ctx.Arch().ArchType.Name, arches) {
176 globalSanitizers = ctx.Config().SanitizeDevice()
177 globalSanitizersDiag = ctx.Config().SanitizeDeviceDiag()
Colin Cross16b23492016-01-06 14:41:07 -0800178 }
179 }
180
Colin Cross16b23492016-01-06 14:41:07 -0800181 if len(globalSanitizers) > 0 {
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000182 var found bool
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700183 if found, globalSanitizers = removeFromList("undefined", globalSanitizers); found && s.All_undefined == nil {
184 s.All_undefined = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000185 }
Colin Cross16b23492016-01-06 14:41:07 -0800186
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700187 if found, globalSanitizers = removeFromList("default-ub", globalSanitizers); found && s.Undefined == nil {
188 s.Undefined = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000189 }
190
Evgenii Stepanov774cb812016-12-28 15:52:54 -0800191 if found, globalSanitizers = removeFromList("address", globalSanitizers); found {
192 if s.Address == nil {
193 s.Address = boolPtr(true)
194 } else if *s.Address == false {
195 // Coverage w/o address is an error. If globalSanitizers includes both, and the module
196 // disables address, then disable coverage as well.
197 _, globalSanitizers = removeFromList("coverage", globalSanitizers)
198 }
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000199 }
200
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700201 if found, globalSanitizers = removeFromList("thread", globalSanitizers); found && s.Thread == nil {
202 s.Thread = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000203 }
204
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700205 if found, globalSanitizers = removeFromList("coverage", globalSanitizers); found && s.Coverage == nil {
206 s.Coverage = boolPtr(true)
207 }
208
209 if found, globalSanitizers = removeFromList("safe-stack", globalSanitizers); found && s.Safestack == nil {
210 s.Safestack = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000211 }
212
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700213 if found, globalSanitizers = removeFromList("cfi", globalSanitizers); found && s.Cfi == nil {
Colin Cross6510f912017-11-29 00:27:14 -0800214 if !ctx.Config().CFIDisabledForPath(ctx.ModuleDir()) {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700215 s.Cfi = boolPtr(true)
216 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700217 }
218
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700219 // Global integer_overflow builds do not support static libraries.
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700220 if found, globalSanitizers = removeFromList("integer_overflow", globalSanitizers); found && s.Integer_overflow == nil {
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700221 if !ctx.Config().IntegerOverflowDisabledForPath(ctx.ModuleDir()) && !ctx.static() {
Ivan Lozano5f595532017-07-13 14:46:05 -0700222 s.Integer_overflow = boolPtr(true)
223 }
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700224 }
225
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700226 if found, globalSanitizers = removeFromList("scudo", globalSanitizers); found && s.Scudo == nil {
227 s.Scudo = boolPtr(true)
228 }
229
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700230 if found, globalSanitizers = removeFromList("hwaddress", globalSanitizers); found && s.Hwaddress == nil {
231 s.Hwaddress = boolPtr(true)
232 }
233
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000234 if len(globalSanitizers) > 0 {
235 ctx.ModuleErrorf("unknown global sanitizer option %s", globalSanitizers[0])
236 }
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700237
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700238 // Global integer_overflow builds do not support static library diagnostics.
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700239 if found, globalSanitizersDiag = removeFromList("integer_overflow", globalSanitizersDiag); found &&
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700240 s.Diag.Integer_overflow == nil && Bool(s.Integer_overflow) && !ctx.static() {
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700241 s.Diag.Integer_overflow = boolPtr(true)
242 }
243
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700244 if found, globalSanitizersDiag = removeFromList("cfi", globalSanitizersDiag); found &&
245 s.Diag.Cfi == nil && Bool(s.Cfi) {
246 s.Diag.Cfi = boolPtr(true)
247 }
248
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700249 if len(globalSanitizersDiag) > 0 {
250 ctx.ModuleErrorf("unknown global sanitizer diagnostics option %s", globalSanitizersDiag[0])
251 }
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700252 }
Colin Cross3c344ef2016-07-18 15:44:56 -0700253
Vishwath Mohan1c54f662018-05-24 18:36:18 -0700254 // Enable CFI for all components in the include paths (for Aarch64 only)
255 if s.Cfi == nil && ctx.Config().CFIEnabledForPath(ctx.ModuleDir()) && ctx.Arch().ArchType == android.Arm64 {
Vishwath Mohan3af8ee02018-03-30 02:55:23 +0000256 s.Cfi = boolPtr(true)
257 if inList("cfi", ctx.Config().SanitizeDeviceDiag()) {
258 s.Diag.Cfi = boolPtr(true)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700259 }
260 }
261
Evgenii Stepanova83fdac2017-01-31 18:37:30 -0800262 // CFI needs gold linker, and mips toolchain does not have one.
Colin Cross6510f912017-11-29 00:27:14 -0800263 if !ctx.Config().EnableCFI() || ctx.Arch().ArchType == android.Mips || ctx.Arch().ArchType == android.Mips64 {
Vishwath Mohan1b017a72017-01-19 13:54:55 -0800264 s.Cfi = nil
265 s.Diag.Cfi = nil
266 }
267
Vishwath Mohan6d67e6e2017-02-07 20:31:41 -0800268 // Also disable CFI for arm32 until b/35157333 is fixed.
269 if ctx.Arch().ArchType == android.Arm {
270 s.Cfi = nil
271 s.Diag.Cfi = nil
272 }
273
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700274 // HWASan requires AArch64 hardware feature (top-byte-ignore).
275 if ctx.Arch().ArchType != android.Arm64 {
276 s.Hwaddress = nil
277 }
278
Vishwath Mohan8f4fdd82017-04-20 07:42:52 -0700279 // Also disable CFI if ASAN is enabled.
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700280 if Bool(s.Address) || Bool(s.Hwaddress) {
Vishwath Mohan8f4fdd82017-04-20 07:42:52 -0700281 s.Cfi = nil
282 s.Diag.Cfi = nil
283 }
284
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700285 // Disable sanitizers that depend on the UBSan runtime for host builds.
Vishwath Mohane7128792017-11-17 11:08:10 -0800286 if ctx.Host() {
287 s.Cfi = nil
288 s.Diag.Cfi = nil
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700289 s.Misc_undefined = nil
290 s.Undefined = nil
291 s.All_undefined = nil
292 s.Integer_overflow = nil
Vishwath Mohane7128792017-11-17 11:08:10 -0800293 }
294
Vishwath Mohan9ccbba02018-05-28 13:54:48 -0700295 // Also disable CFI for VNDK variants of components
296 if ctx.isVndk() && ctx.useVndk() {
Vishwath Mohan7589c822018-05-23 19:29:55 -0700297 s.Cfi = nil
298 s.Diag.Cfi = nil
299 }
300
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700301 // HWASan ramdisk (which is built from recovery) goes over some bootloader limit.
Evgenii Stepanov1e798442018-11-15 17:34:18 -0800302 // Keep libc instrumented so that recovery can run hwasan-instrumented code if necessary.
303 if ctx.inRecovery() && !strings.HasPrefix(ctx.ModuleDir(), "bionic/libc") {
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700304 s.Hwaddress = nil
305 }
306
Colin Cross3c344ef2016-07-18 15:44:56 -0700307 if ctx.staticBinary() {
308 s.Address = nil
Colin Cross91169fe2016-08-11 15:54:20 -0700309 s.Coverage = nil
Colin Cross3c344ef2016-07-18 15:44:56 -0700310 s.Thread = nil
Colin Cross16b23492016-01-06 14:41:07 -0800311 }
312
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700313 if Bool(s.All_undefined) {
314 s.Undefined = nil
315 }
316
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700317 if !ctx.toolchain().Is64Bit() {
318 // TSAN and SafeStack are not supported on 32-bit architectures
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700319 s.Thread = nil
320 s.Safestack = nil
Colin Cross16b23492016-01-06 14:41:07 -0800321 // TODO(ccross): error for compile_multilib = "32"?
322 }
323
Evgenii Stepanov76cee232017-01-27 15:44:44 -0800324 if ctx.Os() != android.Windows && (Bool(s.All_undefined) || Bool(s.Undefined) || Bool(s.Address) || Bool(s.Thread) ||
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700325 Bool(s.Coverage) || Bool(s.Safestack) || Bool(s.Cfi) || Bool(s.Integer_overflow) || len(s.Misc_undefined) > 0 ||
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700326 Bool(s.Scudo) || Bool(s.Hwaddress)) {
Colin Cross3c344ef2016-07-18 15:44:56 -0700327 sanitize.Properties.SanitizerEnabled = true
328 }
329
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700330 // Disable Scudo if ASan or TSan is enabled.
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700331 if Bool(s.Address) || Bool(s.Thread) || Bool(s.Hwaddress) {
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700332 s.Scudo = nil
333 }
334
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700335 if Bool(s.Hwaddress) {
336 s.Address = nil
337 s.Thread = nil
338 }
339
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700340 if Bool(s.Coverage) {
341 if !Bool(s.Address) {
Colin Cross16b23492016-01-06 14:41:07 -0800342 ctx.ModuleErrorf(`Use of "coverage" also requires "address"`)
343 }
344 }
345}
346
347func (sanitize *sanitize) deps(ctx BaseModuleContext, deps Deps) Deps {
348 if !sanitize.Properties.SanitizerEnabled { // || c.static() {
349 return deps
350 }
351
352 if ctx.Device() {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700353 if Bool(sanitize.Properties.Sanitize.Address) {
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700354 deps.StaticLibs = append(deps.StaticLibs, asanLibs...)
Colin Cross16b23492016-01-06 14:41:07 -0800355 }
356 }
357
358 return deps
359}
360
361func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags) Flags {
Ivan Lozano59fdea22018-05-10 14:17:22 -0700362 minimalRuntimeLib := config.UndefinedBehaviorSanitizerMinimalRuntimeLibrary(ctx.toolchain()) + ".a"
363 minimalRuntimePath := "${config.ClangAsanLibDir}/" + minimalRuntimeLib
Ivan Lozano30c5db22018-02-21 15:49:20 -0800364
365 if ctx.Device() && sanitize.Properties.MinimalRuntimeDep {
366 flags.LdFlags = append(flags.LdFlags, minimalRuntimePath)
Ivan Lozano59fdea22018-05-10 14:17:22 -0700367 flags.LdFlags = append(flags.LdFlags, "-Wl,--exclude-libs,"+minimalRuntimeLib)
Ivan Lozano30c5db22018-02-21 15:49:20 -0800368 }
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700369 if !sanitize.Properties.SanitizerEnabled && !sanitize.Properties.UbsanRuntimeDep {
Colin Cross16b23492016-01-06 14:41:07 -0800370 return flags
371 }
372
Colin Cross16b23492016-01-06 14:41:07 -0800373 var sanitizers []string
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700374 var diagSanitizers []string
Colin Cross16b23492016-01-06 14:41:07 -0800375
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700376 if Bool(sanitize.Properties.Sanitize.All_undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800377 sanitizers = append(sanitizers, "undefined")
Colin Cross16b23492016-01-06 14:41:07 -0800378 } else {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700379 if Bool(sanitize.Properties.Sanitize.Undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800380 sanitizers = append(sanitizers,
381 "bool",
382 "integer-divide-by-zero",
383 "return",
384 "returns-nonnull-attribute",
385 "shift-exponent",
386 "unreachable",
387 "vla-bound",
388 // TODO(danalbert): The following checks currently have compiler performance issues.
389 //"alignment",
390 //"bounds",
391 //"enum",
392 //"float-cast-overflow",
393 //"float-divide-by-zero",
394 //"nonnull-attribute",
395 //"null",
396 //"shift-base",
397 //"signed-integer-overflow",
398 // TODO(danalbert): Fix UB in libc++'s __tree so we can turn this on.
399 // https://llvm.org/PR19302
400 // http://reviews.llvm.org/D6974
401 // "object-size",
402 )
403 }
404 sanitizers = append(sanitizers, sanitize.Properties.Sanitize.Misc_undefined...)
405 }
406
Ivan Lozano651275b2017-06-13 10:24:34 -0700407 if Bool(sanitize.Properties.Sanitize.Diag.Undefined) {
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700408 diagSanitizers = append(diagSanitizers, "undefined")
409 }
410
Ivan Lozano651275b2017-06-13 10:24:34 -0700411 diagSanitizers = append(diagSanitizers, sanitize.Properties.Sanitize.Diag.Misc_undefined...)
412
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700413 if Bool(sanitize.Properties.Sanitize.Address) {
Colin Cross635c3b02016-05-18 15:37:25 -0700414 if ctx.Arch().ArchType == android.Arm {
Colin Cross16b23492016-01-06 14:41:07 -0800415 // Frame pointer based unwinder in ASan requires ARM frame setup.
416 // TODO: put in flags?
417 flags.RequiredInstructionSet = "arm"
418 }
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700419 flags.CFlags = append(flags.CFlags, asanCflags...)
420 flags.LdFlags = append(flags.LdFlags, asanLdflags...)
Colin Cross16b23492016-01-06 14:41:07 -0800421
Colin Cross16b23492016-01-06 14:41:07 -0800422 if ctx.Host() {
423 // -nodefaultlibs (provided with libc++) prevents the driver from linking
424 // libraries needed with -fsanitize=address. http://b/18650275 (WAI)
Colin Cross16b23492016-01-06 14:41:07 -0800425 flags.LdFlags = append(flags.LdFlags, "-Wl,--no-as-needed")
426 } else {
427 flags.CFlags = append(flags.CFlags, "-mllvm", "-asan-globals=0")
428 flags.DynamicLinker = "/system/bin/linker_asan"
429 if flags.Toolchain.Is64Bit() {
430 flags.DynamicLinker += "64"
431 }
432 }
433 sanitizers = append(sanitizers, "address")
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700434 diagSanitizers = append(diagSanitizers, "address")
Colin Cross16b23492016-01-06 14:41:07 -0800435 }
436
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700437 if Bool(sanitize.Properties.Sanitize.Hwaddress) {
438 flags.CFlags = append(flags.CFlags, hwasanCflags...)
439 sanitizers = append(sanitizers, "hwaddress")
440 }
441
Yabin Cui6be405e2017-10-19 15:52:11 -0700442 if Bool(sanitize.Properties.Sanitize.Thread) {
443 sanitizers = append(sanitizers, "thread")
444 }
445
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700446 if Bool(sanitize.Properties.Sanitize.Coverage) {
Zach Riggle06bbd892017-08-21 17:12:32 -0400447 flags.CFlags = append(flags.CFlags, "-fsanitize-coverage=trace-pc-guard,indirect-calls,trace-cmp")
Colin Cross16b23492016-01-06 14:41:07 -0800448 }
449
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700450 if Bool(sanitize.Properties.Sanitize.Safestack) {
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700451 sanitizers = append(sanitizers, "safe-stack")
452 }
453
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700454 if Bool(sanitize.Properties.Sanitize.Cfi) {
Evgenii Stepanov7ebf9fa2017-01-20 14:13:06 -0800455 if ctx.Arch().ArchType == android.Arm {
456 // __cfi_check needs to be built as Thumb (see the code in linker_cfi.cpp). LLVM is not set up
457 // to do this on a function basis, so force Thumb on the entire module.
458 flags.RequiredInstructionSet = "thumb"
459 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700460 sanitizers = append(sanitizers, "cfi")
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000461
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700462 flags.CFlags = append(flags.CFlags, cfiCflags...)
Evgenii Stepanovdbf1d4f2018-08-31 12:54:33 -0700463 flags.AsFlags = append(flags.AsFlags, cfiAsflags...)
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000464 // Only append the default visibility flag if -fvisibility has not already been set
465 // to hidden.
466 if !inList("-fvisibility=hidden", flags.CFlags) {
467 flags.CFlags = append(flags.CFlags, "-fvisibility=default")
468 }
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700469 flags.LdFlags = append(flags.LdFlags, cfiLdflags...)
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700470 if Bool(sanitize.Properties.Sanitize.Diag.Cfi) {
471 diagSanitizers = append(diagSanitizers, "cfi")
472 }
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000473
474 if ctx.staticBinary() {
475 _, flags.CFlags = removeFromList("-fsanitize-cfi-cross-dso", flags.CFlags)
476 _, flags.LdFlags = removeFromList("-fsanitize-cfi-cross-dso", flags.LdFlags)
477 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700478 }
479
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700480 if Bool(sanitize.Properties.Sanitize.Integer_overflow) {
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700481 sanitizers = append(sanitizers, "unsigned-integer-overflow")
482 sanitizers = append(sanitizers, "signed-integer-overflow")
483 flags.CFlags = append(flags.CFlags, intOverflowCflags...)
484 if Bool(sanitize.Properties.Sanitize.Diag.Integer_overflow) {
485 diagSanitizers = append(diagSanitizers, "unsigned-integer-overflow")
486 diagSanitizers = append(diagSanitizers, "signed-integer-overflow")
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700487 }
488 }
489
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700490 if Bool(sanitize.Properties.Sanitize.Scudo) {
491 sanitizers = append(sanitizers, "scudo")
492 }
493
Colin Cross16b23492016-01-06 14:41:07 -0800494 if len(sanitizers) > 0 {
495 sanitizeArg := "-fsanitize=" + strings.Join(sanitizers, ",")
Ivan Lozano30c5db22018-02-21 15:49:20 -0800496
Colin Cross16b23492016-01-06 14:41:07 -0800497 flags.CFlags = append(flags.CFlags, sanitizeArg)
Evgenii Stepanovdbf1d4f2018-08-31 12:54:33 -0700498 flags.AsFlags = append(flags.AsFlags, sanitizeArg)
Colin Cross16b23492016-01-06 14:41:07 -0800499 if ctx.Host() {
500 flags.CFlags = append(flags.CFlags, "-fno-sanitize-recover=all")
501 flags.LdFlags = append(flags.LdFlags, sanitizeArg)
Evgenii Stepanov76cee232017-01-27 15:44:44 -0800502 // Host sanitizers only link symbols in the final executable, so
503 // there will always be undefined symbols in intermediate libraries.
504 _, flags.LdFlags = removeFromList("-Wl,--no-undefined", flags.LdFlags)
Colin Cross16b23492016-01-06 14:41:07 -0800505 } else {
Colin Cross263abbd2016-07-15 13:10:48 -0700506 flags.CFlags = append(flags.CFlags, "-fsanitize-trap=all", "-ftrap-function=abort")
Ivan Lozano30c5db22018-02-21 15:49:20 -0800507
508 if enableMinimalRuntime(sanitize) {
509 flags.CFlags = append(flags.CFlags, strings.Join(minimalRuntimeFlags, " "))
510 flags.libFlags = append([]string{minimalRuntimePath}, flags.libFlags...)
Ivan Lozano59fdea22018-05-10 14:17:22 -0700511 flags.LdFlags = append(flags.LdFlags, "-Wl,--exclude-libs,"+minimalRuntimeLib)
Ivan Lozano30c5db22018-02-21 15:49:20 -0800512 }
Colin Cross16b23492016-01-06 14:41:07 -0800513 }
514 }
515
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700516 if len(diagSanitizers) > 0 {
Ivan Lozanob7d0f522018-01-20 01:44:38 +0000517 flags.CFlags = append(flags.CFlags, "-fno-sanitize-trap="+strings.Join(diagSanitizers, ","))
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700518 }
519 // FIXME: enable RTTI if diag + (cfi or vptr)
520
Andreas Gampe97071162017-05-08 13:15:23 -0700521 if sanitize.Properties.Sanitize.Recover != nil {
522 flags.CFlags = append(flags.CFlags, "-fsanitize-recover="+
523 strings.Join(sanitize.Properties.Sanitize.Recover, ","))
524 }
525
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700526 // Link a runtime library if needed.
527 runtimeLibrary := ""
528 if Bool(sanitize.Properties.Sanitize.Address) {
529 runtimeLibrary = config.AddressSanitizerRuntimeLibrary(ctx.toolchain())
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700530 } else if Bool(sanitize.Properties.Sanitize.Hwaddress) {
531 runtimeLibrary = config.HWAddressSanitizerRuntimeLibrary(ctx.toolchain())
Yabin Cui6be405e2017-10-19 15:52:11 -0700532 } else if Bool(sanitize.Properties.Sanitize.Thread) {
533 runtimeLibrary = config.ThreadSanitizerRuntimeLibrary(ctx.toolchain())
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700534 } else if Bool(sanitize.Properties.Sanitize.Scudo) {
Kostya Kortchinskyad73b2e2018-10-11 08:38:39 -0700535 if len(diagSanitizers) == 0 && !sanitize.Properties.UbsanRuntimeDep {
536 runtimeLibrary = config.ScudoMinimalRuntimeLibrary(ctx.toolchain())
537 } else {
538 runtimeLibrary = config.ScudoRuntimeLibrary(ctx.toolchain())
539 }
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700540 } else if len(diagSanitizers) > 0 || sanitize.Properties.UbsanRuntimeDep {
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700541 runtimeLibrary = config.UndefinedBehaviorSanitizerRuntimeLibrary(ctx.toolchain())
542 }
543
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700544 if runtimeLibrary != "" {
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700545 runtimeLibraryPath := "${config.ClangAsanLibDir}/" + runtimeLibrary
546 if !ctx.static() {
547 runtimeLibraryPath = runtimeLibraryPath + ctx.toolchain().ShlibSuffix()
548 } else {
549 runtimeLibraryPath = runtimeLibraryPath + ".a"
550 }
551
Jiyong Park27b188b2017-07-18 13:23:39 +0900552 // ASan runtime library must be the first in the link order.
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700553 flags.libFlags = append([]string{runtimeLibraryPath}, flags.libFlags...)
Colin Cross8ff9ef42017-05-08 13:44:11 -0700554 sanitize.runtimeLibrary = runtimeLibrary
Jiyong Park27b188b2017-07-18 13:23:39 +0900555
556 // When linking against VNDK, use the vendor variant of the runtime lib
557 sanitize.androidMkRuntimeLibrary = sanitize.runtimeLibrary
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700558 if ctx.useVndk() {
Jiyong Park27b188b2017-07-18 13:23:39 +0900559 sanitize.androidMkRuntimeLibrary = sanitize.runtimeLibrary + vendorSuffix
560 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700561 }
562
Colin Cross635c3b02016-05-18 15:37:25 -0700563 blacklist := android.OptionalPathForModuleSrc(ctx, sanitize.Properties.Sanitize.Blacklist)
Colin Cross16b23492016-01-06 14:41:07 -0800564 if blacklist.Valid() {
565 flags.CFlags = append(flags.CFlags, "-fsanitize-blacklist="+blacklist.String())
566 flags.CFlagsDeps = append(flags.CFlagsDeps, blacklist.Path())
567 }
568
569 return flags
570}
571
Colin Cross8ff9ef42017-05-08 13:44:11 -0700572func (sanitize *sanitize) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) {
Colin Cross27a4b052017-08-10 16:32:23 -0700573 ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
Jiyong Park27b188b2017-07-18 13:23:39 +0900574 if sanitize.androidMkRuntimeLibrary != "" {
575 fmt.Fprintln(w, "LOCAL_SHARED_LIBRARIES += "+sanitize.androidMkRuntimeLibrary)
Colin Cross8ff9ef42017-05-08 13:44:11 -0700576 }
Colin Cross8ff9ef42017-05-08 13:44:11 -0700577 })
Vishwath Mohane7128792017-11-17 11:08:10 -0800578
579 // Add a suffix for CFI-enabled static libraries to allow surfacing both to make without a
580 // name conflict.
581 if ret.Class == "STATIC_LIBRARIES" && Bool(sanitize.Properties.Sanitize.Cfi) {
582 ret.SubName += ".cfi"
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000583 }
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700584 if ret.Class == "STATIC_LIBRARIES" && Bool(sanitize.Properties.Sanitize.Hwaddress) {
585 ret.SubName += ".hwasan"
586 }
Colin Cross8ff9ef42017-05-08 13:44:11 -0700587}
588
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700589func (sanitize *sanitize) inSanitizerDir() bool {
590 return sanitize.Properties.InSanitizerDir
Colin Cross30d5f512016-05-03 18:02:42 -0700591}
592
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000593func (sanitize *sanitize) getSanitizerBoolPtr(t sanitizerType) *bool {
Vishwath Mohan95229302017-08-11 00:53:16 +0000594 switch t {
595 case asan:
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000596 return sanitize.Properties.Sanitize.Address
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700597 case hwasan:
598 return sanitize.Properties.Sanitize.Hwaddress
Vishwath Mohan95229302017-08-11 00:53:16 +0000599 case tsan:
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000600 return sanitize.Properties.Sanitize.Thread
Vishwath Mohan95229302017-08-11 00:53:16 +0000601 case intOverflow:
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000602 return sanitize.Properties.Sanitize.Integer_overflow
603 case cfi:
604 return sanitize.Properties.Sanitize.Cfi
Vishwath Mohan95229302017-08-11 00:53:16 +0000605 default:
606 panic(fmt.Errorf("unknown sanitizerType %d", t))
607 }
608}
609
Dan Albert7d1eecf2018-01-19 12:30:45 -0800610func (sanitize *sanitize) isUnsanitizedVariant() bool {
611 return !sanitize.isSanitizerEnabled(asan) &&
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700612 !sanitize.isSanitizerEnabled(hwasan) &&
Dan Albert7d1eecf2018-01-19 12:30:45 -0800613 !sanitize.isSanitizerEnabled(tsan) &&
614 !sanitize.isSanitizerEnabled(cfi)
615}
616
Jayant Chowdharyb7e08ca2018-05-10 15:29:24 -0700617func (sanitize *sanitize) isVariantOnProductionDevice() bool {
618 return !sanitize.isSanitizerEnabled(asan) &&
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700619 !sanitize.isSanitizerEnabled(hwasan) &&
Jayant Chowdharyb7e08ca2018-05-10 15:29:24 -0700620 !sanitize.isSanitizerEnabled(tsan)
621}
622
Colin Cross16b23492016-01-06 14:41:07 -0800623func (sanitize *sanitize) SetSanitizer(t sanitizerType, b bool) {
624 switch t {
625 case asan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700626 sanitize.Properties.Sanitize.Address = boolPtr(b)
Colin Cross91169fe2016-08-11 15:54:20 -0700627 if !b {
628 sanitize.Properties.Sanitize.Coverage = nil
629 }
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700630 case hwasan:
631 sanitize.Properties.Sanitize.Hwaddress = boolPtr(b)
Colin Cross16b23492016-01-06 14:41:07 -0800632 case tsan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700633 sanitize.Properties.Sanitize.Thread = boolPtr(b)
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700634 case intOverflow:
635 sanitize.Properties.Sanitize.Integer_overflow = boolPtr(b)
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000636 case cfi:
637 sanitize.Properties.Sanitize.Cfi = boolPtr(b)
Colin Cross16b23492016-01-06 14:41:07 -0800638 default:
639 panic(fmt.Errorf("unknown sanitizerType %d", t))
640 }
641 if b {
642 sanitize.Properties.SanitizerEnabled = true
643 }
644}
645
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000646// Check if the sanitizer is explicitly disabled (as opposed to nil by
647// virtue of not being set).
648func (sanitize *sanitize) isSanitizerExplicitlyDisabled(t sanitizerType) bool {
649 if sanitize == nil {
650 return false
651 }
652
653 sanitizerVal := sanitize.getSanitizerBoolPtr(t)
654 return sanitizerVal != nil && *sanitizerVal == false
655}
656
657// There isn't an analog of the method above (ie:isSanitizerExplicitlyEnabled)
658// because enabling a sanitizer either directly (via the blueprint) or
659// indirectly (via a mutator) sets the bool ptr to true, and you can't
660// distinguish between the cases. It isn't needed though - both cases can be
661// treated identically.
662func (sanitize *sanitize) isSanitizerEnabled(t sanitizerType) bool {
663 if sanitize == nil {
664 return false
665 }
666
667 sanitizerVal := sanitize.getSanitizerBoolPtr(t)
668 return sanitizerVal != nil && *sanitizerVal == true
669}
670
Colin Cross6b753602018-06-21 13:03:07 -0700671func isSanitizableDependencyTag(tag blueprint.DependencyTag) bool {
672 t, ok := tag.(dependencyTag)
673 return ok && t.library || t == reuseObjTag
674}
675
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700676// Propagate sanitizer requirements down from binaries
Colin Cross635c3b02016-05-18 15:37:25 -0700677func sanitizerDepsMutator(t sanitizerType) func(android.TopDownMutatorContext) {
678 return func(mctx android.TopDownMutatorContext) {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000679 if c, ok := mctx.Module().(*Module); ok && c.sanitize.isSanitizerEnabled(t) {
Colin Cross6b753602018-06-21 13:03:07 -0700680 mctx.WalkDeps(func(child, parent android.Module) bool {
681 if !isSanitizableDependencyTag(mctx.OtherModuleDependencyTag(child)) {
682 return false
683 }
684 if d, ok := child.(*Module); ok && d.sanitize != nil &&
Nan Zhang0007d812017-11-07 10:57:05 -0800685 !Bool(d.sanitize.Properties.Sanitize.Never) &&
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000686 !d.sanitize.isSanitizerExplicitlyDisabled(t) {
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700687 if t == cfi || t == hwasan {
688 if d.static() {
689 d.sanitize.Properties.SanitizeDep = true
690 }
691 } else {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000692 d.sanitize.Properties.SanitizeDep = true
693 }
Colin Cross16b23492016-01-06 14:41:07 -0800694 }
Colin Cross6b753602018-06-21 13:03:07 -0700695 return true
Colin Cross16b23492016-01-06 14:41:07 -0800696 })
697 }
698 }
699}
700
Ivan Lozano30c5db22018-02-21 15:49:20 -0800701// Propagate the ubsan minimal runtime dependency when there are integer overflow sanitized static dependencies.
Colin Cross6b753602018-06-21 13:03:07 -0700702func sanitizerRuntimeDepsMutator(mctx android.TopDownMutatorContext) {
703 if c, ok := mctx.Module().(*Module); ok && c.sanitize != nil {
704 mctx.WalkDeps(func(child, parent android.Module) bool {
705 if !isSanitizableDependencyTag(mctx.OtherModuleDependencyTag(child)) {
706 return false
707 }
708 if d, ok := child.(*Module); ok && d.static() && d.sanitize != nil {
Ivan Lozano30c5db22018-02-21 15:49:20 -0800709
Colin Cross6b753602018-06-21 13:03:07 -0700710 if enableMinimalRuntime(d.sanitize) {
711 // If a static dependency is built with the minimal runtime,
712 // make sure we include the ubsan minimal runtime.
713 c.sanitize.Properties.MinimalRuntimeDep = true
714 } else if Bool(d.sanitize.Properties.Sanitize.Diag.Integer_overflow) ||
715 len(d.sanitize.Properties.Sanitize.Diag.Misc_undefined) > 0 {
716 // If a static dependency runs with full ubsan diagnostics,
717 // make sure we include the ubsan runtime.
718 c.sanitize.Properties.UbsanRuntimeDep = true
Ivan Lozano30c5db22018-02-21 15:49:20 -0800719 }
Colin Cross6b753602018-06-21 13:03:07 -0700720 }
721 return true
722 })
Ivan Lozano30c5db22018-02-21 15:49:20 -0800723 }
724}
725
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000726// Create sanitized variants for modules that need them
Colin Cross635c3b02016-05-18 15:37:25 -0700727func sanitizerMutator(t sanitizerType) func(android.BottomUpMutatorContext) {
728 return func(mctx android.BottomUpMutatorContext) {
Vishwath Mohane6153452017-08-11 00:52:44 +0000729 if c, ok := mctx.Module().(*Module); ok && c.sanitize != nil {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000730 if c.isDependencyRoot() && c.sanitize.isSanitizerEnabled(t) {
Colin Cross30d5f512016-05-03 18:02:42 -0700731 modules := mctx.CreateVariations(t.String())
732 modules[0].(*Module).sanitize.SetSanitizer(t, true)
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000733 } else if c.sanitize.isSanitizerEnabled(t) || c.sanitize.Properties.SanitizeDep {
734 // Save original sanitizer status before we assign values to variant
735 // 0 as that overwrites the original.
736 isSanitizerEnabled := c.sanitize.isSanitizerEnabled(t)
737
Colin Crossb0f28952016-09-19 16:46:53 -0700738 modules := mctx.CreateVariations("", t.String())
739 modules[0].(*Module).sanitize.SetSanitizer(t, false)
740 modules[1].(*Module).sanitize.SetSanitizer(t, true)
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000741
Colin Crossb0f28952016-09-19 16:46:53 -0700742 modules[0].(*Module).sanitize.Properties.SanitizeDep = false
743 modules[1].(*Module).sanitize.Properties.SanitizeDep = false
Vishwath Mohane7128792017-11-17 11:08:10 -0800744
745 // We don't need both variants active for anything but CFI-enabled
746 // target static libraries, so suppress the appropriate variant in
747 // all other cases.
748 if t == cfi {
749 if c.static() {
750 if !mctx.Device() {
751 if isSanitizerEnabled {
752 modules[0].(*Module).Properties.PreventInstall = true
753 modules[0].(*Module).Properties.HideFromMake = true
754 } else {
755 modules[1].(*Module).Properties.PreventInstall = true
756 modules[1].(*Module).Properties.HideFromMake = true
757 }
758 } else {
Colin Cross6510f912017-11-29 00:27:14 -0800759 cfiStaticLibs := cfiStaticLibs(mctx.Config())
Vishwath Mohane7128792017-11-17 11:08:10 -0800760
761 cfiStaticLibsMutex.Lock()
762 *cfiStaticLibs = append(*cfiStaticLibs, c.Name())
763 cfiStaticLibsMutex.Unlock()
764 }
765 } else {
766 modules[0].(*Module).Properties.PreventInstall = true
767 modules[0].(*Module).Properties.HideFromMake = true
768 }
769 } else if t == asan {
770 if mctx.Device() {
771 // CFI and ASAN are currently mutually exclusive so disable
772 // CFI if this is an ASAN variant.
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000773 modules[1].(*Module).sanitize.Properties.InSanitizerDir = true
774 modules[1].(*Module).sanitize.SetSanitizer(cfi, false)
775 }
Vishwath Mohane21fe422017-11-01 19:42:45 -0700776 if isSanitizerEnabled {
777 modules[0].(*Module).Properties.PreventInstall = true
Vishwath Mohane7128792017-11-17 11:08:10 -0800778 modules[0].(*Module).Properties.HideFromMake = true
Vishwath Mohane21fe422017-11-01 19:42:45 -0700779 } else {
780 modules[1].(*Module).Properties.PreventInstall = true
Vishwath Mohane7128792017-11-17 11:08:10 -0800781 modules[1].(*Module).Properties.HideFromMake = true
Vishwath Mohane21fe422017-11-01 19:42:45 -0700782 }
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700783 } else if t == hwasan {
784 if mctx.Device() {
785 // CFI and HWASAN are currently mutually exclusive so disable
786 // CFI if this is an HWASAN variant.
787 modules[1].(*Module).sanitize.SetSanitizer(cfi, false)
788 }
789
790 if c.static() {
791 if c.useVndk() {
792 hwasanVendorStaticLibs := hwasanVendorStaticLibs(mctx.Config())
793 hwasanStaticLibsMutex.Lock()
794 *hwasanVendorStaticLibs = append(*hwasanVendorStaticLibs, c.Name())
795 hwasanStaticLibsMutex.Unlock()
796 } else {
797 hwasanStaticLibs := hwasanStaticLibs(mctx.Config())
798 hwasanStaticLibsMutex.Lock()
799 *hwasanStaticLibs = append(*hwasanStaticLibs, c.Name())
800 hwasanStaticLibsMutex.Unlock()
801 }
802 } else {
803 if isSanitizerEnabled {
804 modules[0].(*Module).Properties.PreventInstall = true
805 modules[0].(*Module).Properties.HideFromMake = true
806 } else {
807 modules[1].(*Module).Properties.PreventInstall = true
808 modules[1].(*Module).Properties.HideFromMake = true
809 }
810 }
Vishwath Mohane21fe422017-11-01 19:42:45 -0700811 }
Colin Cross16b23492016-01-06 14:41:07 -0800812 }
813 c.sanitize.Properties.SanitizeDep = false
814 }
815 }
816}
Vishwath Mohane7128792017-11-17 11:08:10 -0800817
818func cfiStaticLibs(config android.Config) *[]string {
819 return config.Once("cfiStaticLibs", func() interface{} {
820 return &[]string{}
821 }).(*[]string)
822}
823
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700824func hwasanStaticLibs(config android.Config) *[]string {
825 return config.Once("hwasanStaticLibs", func() interface{} {
826 return &[]string{}
827 }).(*[]string)
828}
829
830func hwasanVendorStaticLibs(config android.Config) *[]string {
831 return config.Once("hwasanVendorStaticLibs", func() interface{} {
832 return &[]string{}
833 }).(*[]string)
834}
835
Ivan Lozano30c5db22018-02-21 15:49:20 -0800836func enableMinimalRuntime(sanitize *sanitize) bool {
837 if !Bool(sanitize.Properties.Sanitize.Address) &&
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700838 !Bool(sanitize.Properties.Sanitize.Hwaddress) &&
Ivan Lozano30c5db22018-02-21 15:49:20 -0800839 (Bool(sanitize.Properties.Sanitize.Integer_overflow) ||
840 len(sanitize.Properties.Sanitize.Misc_undefined) > 0) &&
841 !(Bool(sanitize.Properties.Sanitize.Diag.Integer_overflow) ||
842 Bool(sanitize.Properties.Sanitize.Diag.Cfi) ||
843 len(sanitize.Properties.Sanitize.Diag.Misc_undefined) > 0) {
844 return true
845 }
846 return false
847}
848
Vishwath Mohane7128792017-11-17 11:08:10 -0800849func cfiMakeVarsProvider(ctx android.MakeVarsContext) {
850 cfiStaticLibs := cfiStaticLibs(ctx.Config())
Jeff Gaston72765392017-11-28 16:37:53 -0800851 sort.Strings(*cfiStaticLibs)
Vishwath Mohane7128792017-11-17 11:08:10 -0800852 ctx.Strict("SOONG_CFI_STATIC_LIBRARIES", strings.Join(*cfiStaticLibs, " "))
853}
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700854
855func hwasanMakeVarsProvider(ctx android.MakeVarsContext) {
856 hwasanStaticLibs := hwasanStaticLibs(ctx.Config())
857 sort.Strings(*hwasanStaticLibs)
858 ctx.Strict("SOONG_HWASAN_STATIC_LIBRARIES", strings.Join(*hwasanStaticLibs, " "))
859
860 hwasanVendorStaticLibs := hwasanVendorStaticLibs(ctx.Config())
861 sort.Strings(*hwasanVendorStaticLibs)
862 ctx.Strict("SOONG_HWASAN_VENDOR_STATIC_LIBRARIES", strings.Join(*hwasanVendorStaticLibs, " "))
863}