blob: b2fc63feffcff6520f38ddcc992bd4f9e1216dbc [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"}
53 minimalRuntimeFlags = []string{"-fsanitize-minimal-runtime", "-fno-sanitize-trap=integer", "-fno-sanitize-recover=integer"}
Dan Willemsencbceaab2016-10-13 16:44:07 -070054)
55
Colin Cross16b23492016-01-06 14:41:07 -080056type sanitizerType int
57
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070058func boolPtr(v bool) *bool {
59 if v {
60 return &v
61 } else {
62 return nil
63 }
64}
65
Colin Cross16b23492016-01-06 14:41:07 -080066const (
67 asan sanitizerType = iota + 1
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070068 hwasan
Colin Cross16b23492016-01-06 14:41:07 -080069 tsan
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -070070 intOverflow
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000071 cfi
Colin Cross16b23492016-01-06 14:41:07 -080072)
73
74func (t sanitizerType) String() string {
75 switch t {
76 case asan:
77 return "asan"
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070078 case hwasan:
79 return "hwasan"
Colin Cross16b23492016-01-06 14:41:07 -080080 case tsan:
81 return "tsan"
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -070082 case intOverflow:
83 return "intOverflow"
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000084 case cfi:
85 return "cfi"
Colin Cross16b23492016-01-06 14:41:07 -080086 default:
87 panic(fmt.Errorf("unknown sanitizerType %d", t))
88 }
89}
90
91type SanitizeProperties struct {
92 // enable AddressSanitizer, ThreadSanitizer, or UndefinedBehaviorSanitizer
93 Sanitize struct {
Nan Zhang0007d812017-11-07 10:57:05 -080094 Never *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080095
96 // main sanitizers
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070097 Address *bool `android:"arch_variant"`
98 Thread *bool `android:"arch_variant"`
99 Hwaddress *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -0800100
101 // local sanitizers
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700102 Undefined *bool `android:"arch_variant"`
103 All_undefined *bool `android:"arch_variant"`
104 Misc_undefined []string `android:"arch_variant"`
105 Coverage *bool `android:"arch_variant"`
106 Safestack *bool `android:"arch_variant"`
107 Cfi *bool `android:"arch_variant"`
108 Integer_overflow *bool `android:"arch_variant"`
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700109 Scudo *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -0800110
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700111 // Sanitizers to run in the diagnostic mode (as opposed to the release mode).
112 // Replaces abort() on error with a human-readable error message.
113 // Address and Thread sanitizers always run in diagnostic mode.
114 Diag struct {
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700115 Undefined *bool `android:"arch_variant"`
116 Cfi *bool `android:"arch_variant"`
117 Integer_overflow *bool `android:"arch_variant"`
118 Misc_undefined []string `android:"arch_variant"`
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700119 }
120
121 // value to pass to -fsanitize-recover=
Colin Cross16b23492016-01-06 14:41:07 -0800122 Recover []string
123
124 // value to pass to -fsanitize-blacklist
125 Blacklist *string
126 } `android:"arch_variant"`
127
Ivan Lozano30c5db22018-02-21 15:49:20 -0800128 SanitizerEnabled bool `blueprint:"mutated"`
129 SanitizeDep bool `blueprint:"mutated"`
130 MinimalRuntimeDep bool `blueprint:"mutated"`
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700131 UbsanRuntimeDep bool `blueprint:"mutated"`
Ivan Lozano30c5db22018-02-21 15:49:20 -0800132 InSanitizerDir bool `blueprint:"mutated"`
Colin Cross16b23492016-01-06 14:41:07 -0800133}
134
135type sanitize struct {
136 Properties SanitizeProperties
Colin Cross8ff9ef42017-05-08 13:44:11 -0700137
Jiyong Park27b188b2017-07-18 13:23:39 +0900138 runtimeLibrary string
139 androidMkRuntimeLibrary string
Colin Cross16b23492016-01-06 14:41:07 -0800140}
141
Vishwath Mohane7128792017-11-17 11:08:10 -0800142func init() {
143 android.RegisterMakeVarsProvider(pctx, cfiMakeVarsProvider)
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700144 android.RegisterMakeVarsProvider(pctx, hwasanMakeVarsProvider)
Vishwath Mohane7128792017-11-17 11:08:10 -0800145}
146
Colin Cross16b23492016-01-06 14:41:07 -0800147func (sanitize *sanitize) props() []interface{} {
148 return []interface{}{&sanitize.Properties}
149}
150
151func (sanitize *sanitize) begin(ctx BaseModuleContext) {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700152 s := &sanitize.Properties.Sanitize
153
Colin Cross16b23492016-01-06 14:41:07 -0800154 // Don't apply sanitizers to NDK code.
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700155 if ctx.useSdk() {
Nan Zhang0007d812017-11-07 10:57:05 -0800156 s.Never = BoolPtr(true)
Colin Cross16b23492016-01-06 14:41:07 -0800157 }
158
159 // Never always wins.
Nan Zhang0007d812017-11-07 10:57:05 -0800160 if Bool(s.Never) {
Colin Cross16b23492016-01-06 14:41:07 -0800161 return
162 }
163
Colin Cross16b23492016-01-06 14:41:07 -0800164 var globalSanitizers []string
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700165 var globalSanitizersDiag []string
166
Colin Cross16b23492016-01-06 14:41:07 -0800167 if ctx.clang() {
168 if ctx.Host() {
Pirama Arumuga Nainar83d716c2018-06-26 14:01:40 -0700169 if !ctx.Windows() {
170 globalSanitizers = ctx.Config().SanitizeHost()
171 }
Colin Cross16b23492016-01-06 14:41:07 -0800172 } else {
Colin Cross6510f912017-11-29 00:27:14 -0800173 arches := ctx.Config().SanitizeDeviceArch()
Colin Cross23ae82a2016-11-02 14:34:39 -0700174 if len(arches) == 0 || inList(ctx.Arch().ArchType.Name, arches) {
Colin Cross6510f912017-11-29 00:27:14 -0800175 globalSanitizers = ctx.Config().SanitizeDevice()
176 globalSanitizersDiag = ctx.Config().SanitizeDeviceDiag()
Colin Cross23ae82a2016-11-02 14:34:39 -0700177 }
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.
302 if ctx.inRecovery() {
303 s.Hwaddress = nil
304 }
305
Colin Cross3c344ef2016-07-18 15:44:56 -0700306 if ctx.staticBinary() {
307 s.Address = nil
Colin Cross91169fe2016-08-11 15:54:20 -0700308 s.Coverage = nil
Colin Cross3c344ef2016-07-18 15:44:56 -0700309 s.Thread = nil
Colin Cross16b23492016-01-06 14:41:07 -0800310 }
311
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700312 if Bool(s.All_undefined) {
313 s.Undefined = nil
314 }
315
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700316 if !ctx.toolchain().Is64Bit() {
317 // TSAN and SafeStack are not supported on 32-bit architectures
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700318 s.Thread = nil
319 s.Safestack = nil
Colin Cross16b23492016-01-06 14:41:07 -0800320 // TODO(ccross): error for compile_multilib = "32"?
321 }
322
Evgenii Stepanov76cee232017-01-27 15:44:44 -0800323 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 -0700324 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 -0700325 Bool(s.Scudo) || Bool(s.Hwaddress)) {
Colin Cross3c344ef2016-07-18 15:44:56 -0700326 sanitize.Properties.SanitizerEnabled = true
327 }
328
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700329 // Disable Scudo if ASan or TSan is enabled.
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700330 if Bool(s.Address) || Bool(s.Thread) || Bool(s.Hwaddress) {
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700331 s.Scudo = nil
332 }
333
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700334 if Bool(s.Hwaddress) {
335 s.Address = nil
336 s.Thread = nil
337 }
338
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700339 if Bool(s.Coverage) {
340 if !Bool(s.Address) {
Colin Cross16b23492016-01-06 14:41:07 -0800341 ctx.ModuleErrorf(`Use of "coverage" also requires "address"`)
342 }
343 }
344}
345
346func (sanitize *sanitize) deps(ctx BaseModuleContext, deps Deps) Deps {
347 if !sanitize.Properties.SanitizerEnabled { // || c.static() {
348 return deps
349 }
350
351 if ctx.Device() {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700352 if Bool(sanitize.Properties.Sanitize.Address) {
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700353 deps.StaticLibs = append(deps.StaticLibs, asanLibs...)
Colin Cross16b23492016-01-06 14:41:07 -0800354 }
355 }
356
357 return deps
358}
359
360func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags) Flags {
Ivan Lozano59fdea22018-05-10 14:17:22 -0700361 minimalRuntimeLib := config.UndefinedBehaviorSanitizerMinimalRuntimeLibrary(ctx.toolchain()) + ".a"
362 minimalRuntimePath := "${config.ClangAsanLibDir}/" + minimalRuntimeLib
Ivan Lozano30c5db22018-02-21 15:49:20 -0800363
364 if ctx.Device() && sanitize.Properties.MinimalRuntimeDep {
365 flags.LdFlags = append(flags.LdFlags, minimalRuntimePath)
Ivan Lozano59fdea22018-05-10 14:17:22 -0700366 flags.LdFlags = append(flags.LdFlags, "-Wl,--exclude-libs,"+minimalRuntimeLib)
Ivan Lozano30c5db22018-02-21 15:49:20 -0800367 }
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700368 if !sanitize.Properties.SanitizerEnabled && !sanitize.Properties.UbsanRuntimeDep {
Colin Cross16b23492016-01-06 14:41:07 -0800369 return flags
370 }
371
372 if !ctx.clang() {
373 ctx.ModuleErrorf("Use of sanitizers requires clang")
374 }
375
376 var sanitizers []string
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700377 var diagSanitizers []string
Colin Cross16b23492016-01-06 14:41:07 -0800378
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700379 if Bool(sanitize.Properties.Sanitize.All_undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800380 sanitizers = append(sanitizers, "undefined")
Colin Cross16b23492016-01-06 14:41:07 -0800381 } else {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700382 if Bool(sanitize.Properties.Sanitize.Undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800383 sanitizers = append(sanitizers,
384 "bool",
385 "integer-divide-by-zero",
386 "return",
387 "returns-nonnull-attribute",
388 "shift-exponent",
389 "unreachable",
390 "vla-bound",
391 // TODO(danalbert): The following checks currently have compiler performance issues.
392 //"alignment",
393 //"bounds",
394 //"enum",
395 //"float-cast-overflow",
396 //"float-divide-by-zero",
397 //"nonnull-attribute",
398 //"null",
399 //"shift-base",
400 //"signed-integer-overflow",
401 // TODO(danalbert): Fix UB in libc++'s __tree so we can turn this on.
402 // https://llvm.org/PR19302
403 // http://reviews.llvm.org/D6974
404 // "object-size",
405 )
406 }
407 sanitizers = append(sanitizers, sanitize.Properties.Sanitize.Misc_undefined...)
408 }
409
Ivan Lozano651275b2017-06-13 10:24:34 -0700410 if Bool(sanitize.Properties.Sanitize.Diag.Undefined) {
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700411 diagSanitizers = append(diagSanitizers, "undefined")
412 }
413
Ivan Lozano651275b2017-06-13 10:24:34 -0700414 diagSanitizers = append(diagSanitizers, sanitize.Properties.Sanitize.Diag.Misc_undefined...)
415
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700416 if Bool(sanitize.Properties.Sanitize.Address) {
Colin Cross635c3b02016-05-18 15:37:25 -0700417 if ctx.Arch().ArchType == android.Arm {
Colin Cross16b23492016-01-06 14:41:07 -0800418 // Frame pointer based unwinder in ASan requires ARM frame setup.
419 // TODO: put in flags?
420 flags.RequiredInstructionSet = "arm"
421 }
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700422 flags.CFlags = append(flags.CFlags, asanCflags...)
423 flags.LdFlags = append(flags.LdFlags, asanLdflags...)
Colin Cross16b23492016-01-06 14:41:07 -0800424
Colin Cross16b23492016-01-06 14:41:07 -0800425 if ctx.Host() {
426 // -nodefaultlibs (provided with libc++) prevents the driver from linking
427 // libraries needed with -fsanitize=address. http://b/18650275 (WAI)
Colin Cross16b23492016-01-06 14:41:07 -0800428 flags.LdFlags = append(flags.LdFlags, "-Wl,--no-as-needed")
429 } else {
430 flags.CFlags = append(flags.CFlags, "-mllvm", "-asan-globals=0")
431 flags.DynamicLinker = "/system/bin/linker_asan"
432 if flags.Toolchain.Is64Bit() {
433 flags.DynamicLinker += "64"
434 }
435 }
436 sanitizers = append(sanitizers, "address")
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700437 diagSanitizers = append(diagSanitizers, "address")
Colin Cross16b23492016-01-06 14:41:07 -0800438 }
439
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700440 if Bool(sanitize.Properties.Sanitize.Hwaddress) {
441 flags.CFlags = append(flags.CFlags, hwasanCflags...)
442 sanitizers = append(sanitizers, "hwaddress")
443 }
444
Yabin Cui6be405e2017-10-19 15:52:11 -0700445 if Bool(sanitize.Properties.Sanitize.Thread) {
446 sanitizers = append(sanitizers, "thread")
447 }
448
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700449 if Bool(sanitize.Properties.Sanitize.Coverage) {
Zach Riggle06bbd892017-08-21 17:12:32 -0400450 flags.CFlags = append(flags.CFlags, "-fsanitize-coverage=trace-pc-guard,indirect-calls,trace-cmp")
Colin Cross16b23492016-01-06 14:41:07 -0800451 }
452
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700453 if Bool(sanitize.Properties.Sanitize.Safestack) {
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700454 sanitizers = append(sanitizers, "safe-stack")
455 }
456
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700457 if Bool(sanitize.Properties.Sanitize.Cfi) {
Evgenii Stepanov7ebf9fa2017-01-20 14:13:06 -0800458 if ctx.Arch().ArchType == android.Arm {
459 // __cfi_check needs to be built as Thumb (see the code in linker_cfi.cpp). LLVM is not set up
460 // to do this on a function basis, so force Thumb on the entire module.
461 flags.RequiredInstructionSet = "thumb"
462 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700463 sanitizers = append(sanitizers, "cfi")
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000464
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700465 flags.CFlags = append(flags.CFlags, cfiCflags...)
Evgenii Stepanovdbf1d4f2018-08-31 12:54:33 -0700466 flags.AsFlags = append(flags.AsFlags, cfiAsflags...)
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000467 // Only append the default visibility flag if -fvisibility has not already been set
468 // to hidden.
469 if !inList("-fvisibility=hidden", flags.CFlags) {
470 flags.CFlags = append(flags.CFlags, "-fvisibility=default")
471 }
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700472 flags.LdFlags = append(flags.LdFlags, cfiLdflags...)
Zhizhou Yang51be6322018-02-08 18:32:11 -0800473 flags.ArGoldPlugin = true
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700474 if Bool(sanitize.Properties.Sanitize.Diag.Cfi) {
475 diagSanitizers = append(diagSanitizers, "cfi")
476 }
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000477
478 if ctx.staticBinary() {
479 _, flags.CFlags = removeFromList("-fsanitize-cfi-cross-dso", flags.CFlags)
480 _, flags.LdFlags = removeFromList("-fsanitize-cfi-cross-dso", flags.LdFlags)
481 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700482 }
483
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700484 if Bool(sanitize.Properties.Sanitize.Integer_overflow) {
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700485 sanitizers = append(sanitizers, "unsigned-integer-overflow")
486 sanitizers = append(sanitizers, "signed-integer-overflow")
487 flags.CFlags = append(flags.CFlags, intOverflowCflags...)
488 if Bool(sanitize.Properties.Sanitize.Diag.Integer_overflow) {
489 diagSanitizers = append(diagSanitizers, "unsigned-integer-overflow")
490 diagSanitizers = append(diagSanitizers, "signed-integer-overflow")
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700491 }
492 }
493
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700494 if Bool(sanitize.Properties.Sanitize.Scudo) {
495 sanitizers = append(sanitizers, "scudo")
496 }
497
Colin Cross16b23492016-01-06 14:41:07 -0800498 if len(sanitizers) > 0 {
499 sanitizeArg := "-fsanitize=" + strings.Join(sanitizers, ",")
Ivan Lozano30c5db22018-02-21 15:49:20 -0800500
Colin Cross16b23492016-01-06 14:41:07 -0800501 flags.CFlags = append(flags.CFlags, sanitizeArg)
Evgenii Stepanovdbf1d4f2018-08-31 12:54:33 -0700502 flags.AsFlags = append(flags.AsFlags, sanitizeArg)
Colin Cross16b23492016-01-06 14:41:07 -0800503 if ctx.Host() {
504 flags.CFlags = append(flags.CFlags, "-fno-sanitize-recover=all")
505 flags.LdFlags = append(flags.LdFlags, sanitizeArg)
Evgenii Stepanov76cee232017-01-27 15:44:44 -0800506 // Host sanitizers only link symbols in the final executable, so
507 // there will always be undefined symbols in intermediate libraries.
508 _, flags.LdFlags = removeFromList("-Wl,--no-undefined", flags.LdFlags)
Colin Cross16b23492016-01-06 14:41:07 -0800509 } else {
Colin Cross263abbd2016-07-15 13:10:48 -0700510 flags.CFlags = append(flags.CFlags, "-fsanitize-trap=all", "-ftrap-function=abort")
Ivan Lozano30c5db22018-02-21 15:49:20 -0800511
512 if enableMinimalRuntime(sanitize) {
513 flags.CFlags = append(flags.CFlags, strings.Join(minimalRuntimeFlags, " "))
514 flags.libFlags = append([]string{minimalRuntimePath}, flags.libFlags...)
Ivan Lozano59fdea22018-05-10 14:17:22 -0700515 flags.LdFlags = append(flags.LdFlags, "-Wl,--exclude-libs,"+minimalRuntimeLib)
Ivan Lozano30c5db22018-02-21 15:49:20 -0800516 }
Colin Cross16b23492016-01-06 14:41:07 -0800517 }
518 }
519
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700520 if len(diagSanitizers) > 0 {
Ivan Lozanob7d0f522018-01-20 01:44:38 +0000521 flags.CFlags = append(flags.CFlags, "-fno-sanitize-trap="+strings.Join(diagSanitizers, ","))
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700522 }
523 // FIXME: enable RTTI if diag + (cfi or vptr)
524
Andreas Gampe97071162017-05-08 13:15:23 -0700525 if sanitize.Properties.Sanitize.Recover != nil {
526 flags.CFlags = append(flags.CFlags, "-fsanitize-recover="+
527 strings.Join(sanitize.Properties.Sanitize.Recover, ","))
528 }
529
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700530 // Link a runtime library if needed.
531 runtimeLibrary := ""
532 if Bool(sanitize.Properties.Sanitize.Address) {
533 runtimeLibrary = config.AddressSanitizerRuntimeLibrary(ctx.toolchain())
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700534 } else if Bool(sanitize.Properties.Sanitize.Hwaddress) {
535 runtimeLibrary = config.HWAddressSanitizerRuntimeLibrary(ctx.toolchain())
Yabin Cui6be405e2017-10-19 15:52:11 -0700536 } else if Bool(sanitize.Properties.Sanitize.Thread) {
537 runtimeLibrary = config.ThreadSanitizerRuntimeLibrary(ctx.toolchain())
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700538 } else if Bool(sanitize.Properties.Sanitize.Scudo) {
539 runtimeLibrary = config.ScudoRuntimeLibrary(ctx.toolchain())
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) &&
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700839 !Bool(sanitize.Properties.Sanitize.Scudo) &&
Ivan Lozano30c5db22018-02-21 15:49:20 -0800840 (Bool(sanitize.Properties.Sanitize.Integer_overflow) ||
841 len(sanitize.Properties.Sanitize.Misc_undefined) > 0) &&
842 !(Bool(sanitize.Properties.Sanitize.Diag.Integer_overflow) ||
843 Bool(sanitize.Properties.Sanitize.Diag.Cfi) ||
844 len(sanitize.Properties.Sanitize.Diag.Misc_undefined) > 0) {
845 return true
846 }
847 return false
848}
849
Vishwath Mohane7128792017-11-17 11:08:10 -0800850func cfiMakeVarsProvider(ctx android.MakeVarsContext) {
851 cfiStaticLibs := cfiStaticLibs(ctx.Config())
Jeff Gaston72765392017-11-28 16:37:53 -0800852 sort.Strings(*cfiStaticLibs)
Vishwath Mohane7128792017-11-17 11:08:10 -0800853 ctx.Strict("SOONG_CFI_STATIC_LIBRARIES", strings.Join(*cfiStaticLibs, " "))
854}
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700855
856func hwasanMakeVarsProvider(ctx android.MakeVarsContext) {
857 hwasanStaticLibs := hwasanStaticLibs(ctx.Config())
858 sort.Strings(*hwasanStaticLibs)
859 ctx.Strict("SOONG_HWASAN_STATIC_LIBRARIES", strings.Join(*hwasanStaticLibs, " "))
860
861 hwasanVendorStaticLibs := hwasanVendorStaticLibs(ctx.Config())
862 sort.Strings(*hwasanVendorStaticLibs)
863 ctx.Strict("SOONG_HWASAN_VENDOR_STATIC_LIBRARIES", strings.Join(*hwasanVendorStaticLibs, " "))
864}