blob: 205b2a205e0532fe126801e80edecf3eb3db2f2d [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 Cross635c3b02016-05-18 15:37:25 -070024 "android/soong/android"
Evgenii Stepanovaf36db12016-08-15 14:18:24 -070025 "android/soong/cc/config"
Colin Cross16b23492016-01-06 14:41:07 -080026)
27
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -070028var (
29 // Any C flags added by sanitizer which libTooling tools may not
30 // understand also need to be added to ClangLibToolingUnknownCflags in
31 // cc/config/clang.go
Vishwath Mohanf3918d32017-02-14 07:59:33 -080032
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -070033 asanCflags = []string{"-fno-omit-frame-pointer"}
34 asanLdflags = []string{"-Wl,-u,__asan_preinit"}
35 asanLibs = []string{"libasan"}
36
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000037 cfiCflags = []string{"-flto", "-fsanitize-cfi-cross-dso",
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -070038 "-fsanitize-blacklist=external/compiler-rt/lib/cfi/cfi_blacklist.txt"}
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -070039 cfiLdflags = []string{"-flto", "-fsanitize-cfi-cross-dso", "-fsanitize=cfi",
Pirama Arumuga Nainarbdb17f02017-08-28 21:50:17 -070040 "-Wl,-plugin-opt,O1"}
Vishwath Mohane7128792017-11-17 11:08:10 -080041 cfiExportsMapPath = "build/soong/cc/config/cfi_exports.map"
Vishwath Mohane7128792017-11-17 11:08:10 -080042 cfiStaticLibsMutex sync.Mutex
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -070043
Ivan Lozano954f4302018-02-21 15:49:20 -080044 intOverflowCflags = []string{"-fsanitize-blacklist=build/soong/cc/config/integer_overflow_blacklist.txt"}
45 minimalRuntimeFlags = []string{"-fsanitize-minimal-runtime", "-fno-sanitize-trap=integer", "-fno-sanitize-recover=integer"}
Dan Willemsencbceaab2016-10-13 16:44:07 -070046)
47
Colin Cross16b23492016-01-06 14:41:07 -080048type sanitizerType int
49
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070050func boolPtr(v bool) *bool {
51 if v {
52 return &v
53 } else {
54 return nil
55 }
56}
57
Colin Cross16b23492016-01-06 14:41:07 -080058const (
59 asan sanitizerType = iota + 1
60 tsan
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -070061 intOverflow
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000062 cfi
Colin Cross16b23492016-01-06 14:41:07 -080063)
64
65func (t sanitizerType) String() string {
66 switch t {
67 case asan:
68 return "asan"
69 case tsan:
70 return "tsan"
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -070071 case intOverflow:
72 return "intOverflow"
Vishwath Mohanb743e9c2017-11-01 09:20:21 +000073 case cfi:
74 return "cfi"
Colin Cross16b23492016-01-06 14:41:07 -080075 default:
76 panic(fmt.Errorf("unknown sanitizerType %d", t))
77 }
78}
79
80type SanitizeProperties struct {
81 // enable AddressSanitizer, ThreadSanitizer, or UndefinedBehaviorSanitizer
82 Sanitize struct {
Nan Zhang0007d812017-11-07 10:57:05 -080083 Never *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080084
85 // main sanitizers
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070086 Address *bool `android:"arch_variant"`
87 Thread *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080088
89 // local sanitizers
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -070090 Undefined *bool `android:"arch_variant"`
91 All_undefined *bool `android:"arch_variant"`
92 Misc_undefined []string `android:"arch_variant"`
93 Coverage *bool `android:"arch_variant"`
94 Safestack *bool `android:"arch_variant"`
95 Cfi *bool `android:"arch_variant"`
96 Integer_overflow *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080097
Evgenii Stepanov1e405e12016-08-16 15:39:54 -070098 // Sanitizers to run in the diagnostic mode (as opposed to the release mode).
99 // Replaces abort() on error with a human-readable error message.
100 // Address and Thread sanitizers always run in diagnostic mode.
101 Diag struct {
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700102 Undefined *bool `android:"arch_variant"`
103 Cfi *bool `android:"arch_variant"`
104 Integer_overflow *bool `android:"arch_variant"`
105 Misc_undefined []string `android:"arch_variant"`
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700106 }
107
108 // value to pass to -fsanitize-recover=
Colin Cross16b23492016-01-06 14:41:07 -0800109 Recover []string
110
111 // value to pass to -fsanitize-blacklist
112 Blacklist *string
113 } `android:"arch_variant"`
114
Ivan Lozano954f4302018-02-21 15:49:20 -0800115 SanitizerEnabled bool `blueprint:"mutated"`
116 SanitizeDep bool `blueprint:"mutated"`
117 MinimalRuntimeDep bool `blueprint:"mutated"`
118 InSanitizerDir bool `blueprint:"mutated"`
Colin Cross16b23492016-01-06 14:41:07 -0800119}
120
121type sanitize struct {
122 Properties SanitizeProperties
Colin Cross8ff9ef42017-05-08 13:44:11 -0700123
Jiyong Park27b188b2017-07-18 13:23:39 +0900124 runtimeLibrary string
125 androidMkRuntimeLibrary string
Colin Cross16b23492016-01-06 14:41:07 -0800126}
127
Vishwath Mohane7128792017-11-17 11:08:10 -0800128func init() {
129 android.RegisterMakeVarsProvider(pctx, cfiMakeVarsProvider)
130}
131
Colin Cross16b23492016-01-06 14:41:07 -0800132func (sanitize *sanitize) props() []interface{} {
133 return []interface{}{&sanitize.Properties}
134}
135
136func (sanitize *sanitize) begin(ctx BaseModuleContext) {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700137 s := &sanitize.Properties.Sanitize
138
Colin Cross16b23492016-01-06 14:41:07 -0800139 // Don't apply sanitizers to NDK code.
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700140 if ctx.useSdk() {
Nan Zhang0007d812017-11-07 10:57:05 -0800141 s.Never = BoolPtr(true)
Colin Cross16b23492016-01-06 14:41:07 -0800142 }
143
144 // Never always wins.
Nan Zhang0007d812017-11-07 10:57:05 -0800145 if Bool(s.Never) {
Colin Cross16b23492016-01-06 14:41:07 -0800146 return
147 }
148
Colin Cross16b23492016-01-06 14:41:07 -0800149 var globalSanitizers []string
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700150 var globalSanitizersDiag []string
151
Colin Cross16b23492016-01-06 14:41:07 -0800152 if ctx.clang() {
153 if ctx.Host() {
Colin Cross6510f912017-11-29 00:27:14 -0800154 globalSanitizers = ctx.Config().SanitizeHost()
Colin Cross16b23492016-01-06 14:41:07 -0800155 } else {
Colin Cross6510f912017-11-29 00:27:14 -0800156 arches := ctx.Config().SanitizeDeviceArch()
Colin Cross23ae82a2016-11-02 14:34:39 -0700157 if len(arches) == 0 || inList(ctx.Arch().ArchType.Name, arches) {
Colin Cross6510f912017-11-29 00:27:14 -0800158 globalSanitizers = ctx.Config().SanitizeDevice()
159 globalSanitizersDiag = ctx.Config().SanitizeDeviceDiag()
Colin Cross23ae82a2016-11-02 14:34:39 -0700160 }
Colin Cross16b23492016-01-06 14:41:07 -0800161 }
162 }
163
Colin Cross16b23492016-01-06 14:41:07 -0800164 if len(globalSanitizers) > 0 {
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000165 var found bool
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700166 if found, globalSanitizers = removeFromList("undefined", globalSanitizers); found && s.All_undefined == nil {
167 s.All_undefined = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000168 }
Colin Cross16b23492016-01-06 14:41:07 -0800169
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700170 if found, globalSanitizers = removeFromList("default-ub", globalSanitizers); found && s.Undefined == nil {
171 s.Undefined = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000172 }
173
Evgenii Stepanov774cb812016-12-28 15:52:54 -0800174 if found, globalSanitizers = removeFromList("address", globalSanitizers); found {
175 if s.Address == nil {
176 s.Address = boolPtr(true)
177 } else if *s.Address == false {
178 // Coverage w/o address is an error. If globalSanitizers includes both, and the module
179 // disables address, then disable coverage as well.
180 _, globalSanitizers = removeFromList("coverage", globalSanitizers)
181 }
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000182 }
183
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700184 if found, globalSanitizers = removeFromList("thread", globalSanitizers); found && s.Thread == nil {
185 s.Thread = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000186 }
187
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700188 if found, globalSanitizers = removeFromList("coverage", globalSanitizers); found && s.Coverage == nil {
189 s.Coverage = boolPtr(true)
190 }
191
192 if found, globalSanitizers = removeFromList("safe-stack", globalSanitizers); found && s.Safestack == nil {
193 s.Safestack = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000194 }
195
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700196 if found, globalSanitizers = removeFromList("cfi", globalSanitizers); found && s.Cfi == nil {
Colin Cross6510f912017-11-29 00:27:14 -0800197 if !ctx.Config().CFIDisabledForPath(ctx.ModuleDir()) {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700198 s.Cfi = boolPtr(true)
199 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700200 }
201
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700202 if found, globalSanitizers = removeFromList("integer_overflow", globalSanitizers); found && s.Integer_overflow == nil {
Colin Cross6510f912017-11-29 00:27:14 -0800203 if !ctx.Config().IntegerOverflowDisabledForPath(ctx.ModuleDir()) {
Ivan Lozano5f595532017-07-13 14:46:05 -0700204 s.Integer_overflow = boolPtr(true)
205 }
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700206 }
207
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000208 if len(globalSanitizers) > 0 {
209 ctx.ModuleErrorf("unknown global sanitizer option %s", globalSanitizers[0])
210 }
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700211
212 if found, globalSanitizersDiag = removeFromList("integer_overflow", globalSanitizersDiag); found &&
213 s.Diag.Integer_overflow == nil && Bool(s.Integer_overflow) {
214 s.Diag.Integer_overflow = boolPtr(true)
215 }
216
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700217 if found, globalSanitizersDiag = removeFromList("cfi", globalSanitizersDiag); found &&
218 s.Diag.Cfi == nil && Bool(s.Cfi) {
219 s.Diag.Cfi = boolPtr(true)
220 }
221
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700222 if len(globalSanitizersDiag) > 0 {
223 ctx.ModuleErrorf("unknown global sanitizer diagnostics option %s", globalSanitizersDiag[0])
224 }
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700225 }
Colin Cross3c344ef2016-07-18 15:44:56 -0700226
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700227 // Enable CFI for all components in the include paths
Colin Cross6510f912017-11-29 00:27:14 -0800228 if s.Cfi == nil && ctx.Config().CFIEnabledForPath(ctx.ModuleDir()) {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700229 s.Cfi = boolPtr(true)
Colin Cross6510f912017-11-29 00:27:14 -0800230 if inList("cfi", ctx.Config().SanitizeDeviceDiag()) {
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700231 s.Diag.Cfi = boolPtr(true)
232 }
233 }
234
Evgenii Stepanova83fdac2017-01-31 18:37:30 -0800235 // CFI needs gold linker, and mips toolchain does not have one.
Colin Cross6510f912017-11-29 00:27:14 -0800236 if !ctx.Config().EnableCFI() || ctx.Arch().ArchType == android.Mips || ctx.Arch().ArchType == android.Mips64 {
Vishwath Mohan1b017a72017-01-19 13:54:55 -0800237 s.Cfi = nil
238 s.Diag.Cfi = nil
239 }
240
Vishwath Mohan6d67e6e2017-02-07 20:31:41 -0800241 // Also disable CFI for arm32 until b/35157333 is fixed.
242 if ctx.Arch().ArchType == android.Arm {
243 s.Cfi = nil
244 s.Diag.Cfi = nil
245 }
246
Vishwath Mohan8f4fdd82017-04-20 07:42:52 -0700247 // Also disable CFI if ASAN is enabled.
248 if Bool(s.Address) {
249 s.Cfi = nil
250 s.Diag.Cfi = nil
251 }
252
Vishwath Mohane7128792017-11-17 11:08:10 -0800253 // Also disable CFI for host builds.
254 if ctx.Host() {
255 s.Cfi = nil
256 s.Diag.Cfi = nil
257 }
258
Vishwath Mohan7589c822018-05-23 19:29:55 -0700259 // Also disable CFI for VNDK variants of components in the
260 // include paths
261 if ctx.isVndk() && ctx.useVndk() && ctx.Config().CFIEnabledForPath(ctx.ModuleDir()) {
262 s.Cfi = nil
263 s.Diag.Cfi = nil
264 }
265
Colin Cross3c344ef2016-07-18 15:44:56 -0700266 if ctx.staticBinary() {
267 s.Address = nil
Colin Cross91169fe2016-08-11 15:54:20 -0700268 s.Coverage = nil
Colin Cross3c344ef2016-07-18 15:44:56 -0700269 s.Thread = nil
Colin Cross16b23492016-01-06 14:41:07 -0800270 }
271
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700272 if Bool(s.All_undefined) {
273 s.Undefined = nil
274 }
275
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700276 if !ctx.toolchain().Is64Bit() {
277 // TSAN and SafeStack are not supported on 32-bit architectures
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700278 s.Thread = nil
279 s.Safestack = nil
Colin Cross16b23492016-01-06 14:41:07 -0800280 // TODO(ccross): error for compile_multilib = "32"?
281 }
282
Evgenii Stepanov76cee232017-01-27 15:44:44 -0800283 if ctx.Os() != android.Windows && (Bool(s.All_undefined) || Bool(s.Undefined) || Bool(s.Address) || Bool(s.Thread) ||
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700284 Bool(s.Coverage) || Bool(s.Safestack) || Bool(s.Cfi) || Bool(s.Integer_overflow) || len(s.Misc_undefined) > 0) {
Colin Cross3c344ef2016-07-18 15:44:56 -0700285 sanitize.Properties.SanitizerEnabled = true
286 }
287
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700288 if Bool(s.Coverage) {
289 if !Bool(s.Address) {
Colin Cross16b23492016-01-06 14:41:07 -0800290 ctx.ModuleErrorf(`Use of "coverage" also requires "address"`)
291 }
292 }
293}
294
295func (sanitize *sanitize) deps(ctx BaseModuleContext, deps Deps) Deps {
296 if !sanitize.Properties.SanitizerEnabled { // || c.static() {
297 return deps
298 }
299
300 if ctx.Device() {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700301 if Bool(sanitize.Properties.Sanitize.Address) {
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700302 deps.StaticLibs = append(deps.StaticLibs, asanLibs...)
Colin Cross16b23492016-01-06 14:41:07 -0800303 }
304 }
305
306 return deps
307}
308
309func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags) Flags {
Ivan Lozano1838ef92018-05-10 14:17:22 -0700310 minimalRuntimeLib := config.UndefinedBehaviorSanitizerMinimalRuntimeLibrary(ctx.toolchain()) + ".a"
311 minimalRuntimePath := "${config.ClangAsanLibDir}/" + minimalRuntimeLib
Ivan Lozano954f4302018-02-21 15:49:20 -0800312
313 if ctx.Device() && sanitize.Properties.MinimalRuntimeDep {
314 flags.LdFlags = append(flags.LdFlags, minimalRuntimePath)
Ivan Lozano1838ef92018-05-10 14:17:22 -0700315 flags.LdFlags = append(flags.LdFlags, "-Wl,--exclude-libs,"+minimalRuntimeLib)
Ivan Lozano954f4302018-02-21 15:49:20 -0800316 }
Colin Cross16b23492016-01-06 14:41:07 -0800317 if !sanitize.Properties.SanitizerEnabled {
318 return flags
319 }
320
321 if !ctx.clang() {
322 ctx.ModuleErrorf("Use of sanitizers requires clang")
323 }
324
325 var sanitizers []string
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700326 var diagSanitizers []string
Colin Cross16b23492016-01-06 14:41:07 -0800327
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700328 if Bool(sanitize.Properties.Sanitize.All_undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800329 sanitizers = append(sanitizers, "undefined")
Colin Cross16b23492016-01-06 14:41:07 -0800330 } else {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700331 if Bool(sanitize.Properties.Sanitize.Undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800332 sanitizers = append(sanitizers,
333 "bool",
334 "integer-divide-by-zero",
335 "return",
336 "returns-nonnull-attribute",
337 "shift-exponent",
338 "unreachable",
339 "vla-bound",
340 // TODO(danalbert): The following checks currently have compiler performance issues.
341 //"alignment",
342 //"bounds",
343 //"enum",
344 //"float-cast-overflow",
345 //"float-divide-by-zero",
346 //"nonnull-attribute",
347 //"null",
348 //"shift-base",
349 //"signed-integer-overflow",
350 // TODO(danalbert): Fix UB in libc++'s __tree so we can turn this on.
351 // https://llvm.org/PR19302
352 // http://reviews.llvm.org/D6974
353 // "object-size",
354 )
355 }
356 sanitizers = append(sanitizers, sanitize.Properties.Sanitize.Misc_undefined...)
357 }
358
Ivan Lozano651275b2017-06-13 10:24:34 -0700359 if Bool(sanitize.Properties.Sanitize.Diag.Undefined) {
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700360 diagSanitizers = append(diagSanitizers, "undefined")
361 }
362
Ivan Lozano651275b2017-06-13 10:24:34 -0700363 diagSanitizers = append(diagSanitizers, sanitize.Properties.Sanitize.Diag.Misc_undefined...)
364
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700365 if Bool(sanitize.Properties.Sanitize.Address) {
Colin Cross635c3b02016-05-18 15:37:25 -0700366 if ctx.Arch().ArchType == android.Arm {
Colin Cross16b23492016-01-06 14:41:07 -0800367 // Frame pointer based unwinder in ASan requires ARM frame setup.
368 // TODO: put in flags?
369 flags.RequiredInstructionSet = "arm"
370 }
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700371 flags.CFlags = append(flags.CFlags, asanCflags...)
372 flags.LdFlags = append(flags.LdFlags, asanLdflags...)
Colin Cross16b23492016-01-06 14:41:07 -0800373
Colin Cross16b23492016-01-06 14:41:07 -0800374 if ctx.Host() {
375 // -nodefaultlibs (provided with libc++) prevents the driver from linking
376 // libraries needed with -fsanitize=address. http://b/18650275 (WAI)
Colin Cross16b23492016-01-06 14:41:07 -0800377 flags.LdFlags = append(flags.LdFlags, "-Wl,--no-as-needed")
378 } else {
379 flags.CFlags = append(flags.CFlags, "-mllvm", "-asan-globals=0")
380 flags.DynamicLinker = "/system/bin/linker_asan"
381 if flags.Toolchain.Is64Bit() {
382 flags.DynamicLinker += "64"
383 }
384 }
385 sanitizers = append(sanitizers, "address")
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700386 diagSanitizers = append(diagSanitizers, "address")
Colin Cross16b23492016-01-06 14:41:07 -0800387 }
388
Yabin Cui6be405e2017-10-19 15:52:11 -0700389 if Bool(sanitize.Properties.Sanitize.Thread) {
390 sanitizers = append(sanitizers, "thread")
391 }
392
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700393 if Bool(sanitize.Properties.Sanitize.Coverage) {
Zach Riggle06bbd892017-08-21 17:12:32 -0400394 flags.CFlags = append(flags.CFlags, "-fsanitize-coverage=trace-pc-guard,indirect-calls,trace-cmp")
Colin Cross16b23492016-01-06 14:41:07 -0800395 }
396
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700397 if Bool(sanitize.Properties.Sanitize.Safestack) {
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700398 sanitizers = append(sanitizers, "safe-stack")
399 }
400
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700401 if Bool(sanitize.Properties.Sanitize.Cfi) {
Evgenii Stepanov7ebf9fa2017-01-20 14:13:06 -0800402 if ctx.Arch().ArchType == android.Arm {
403 // __cfi_check needs to be built as Thumb (see the code in linker_cfi.cpp). LLVM is not set up
404 // to do this on a function basis, so force Thumb on the entire module.
405 flags.RequiredInstructionSet = "thumb"
406 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700407 sanitizers = append(sanitizers, "cfi")
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000408
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700409 flags.CFlags = append(flags.CFlags, cfiCflags...)
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000410 // Only append the default visibility flag if -fvisibility has not already been set
411 // to hidden.
412 if !inList("-fvisibility=hidden", flags.CFlags) {
413 flags.CFlags = append(flags.CFlags, "-fvisibility=default")
414 }
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -0700415 flags.LdFlags = append(flags.LdFlags, cfiLdflags...)
Ryan Prichard3ed1f702018-02-05 23:45:16 -0800416 if ctx.Device() {
417 // Work around a bug in Clang. The CFI sanitizer requires LTO, and when
418 // LTO is enabled, the Clang driver fails to enable emutls for Android.
419 // See b/72706604 or https://github.com/android-ndk/ndk/issues/498.
420 flags.LdFlags = append(flags.LdFlags, "-Wl,-plugin-opt,-emulated-tls")
421 }
Zhizhou Yang49170492018-02-08 18:32:11 -0800422 flags.ArGoldPlugin = true
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700423 if Bool(sanitize.Properties.Sanitize.Diag.Cfi) {
424 diagSanitizers = append(diagSanitizers, "cfi")
425 }
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000426
427 if ctx.staticBinary() {
428 _, flags.CFlags = removeFromList("-fsanitize-cfi-cross-dso", flags.CFlags)
429 _, flags.LdFlags = removeFromList("-fsanitize-cfi-cross-dso", flags.LdFlags)
430 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700431 }
432
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700433 if Bool(sanitize.Properties.Sanitize.Integer_overflow) {
434 if !ctx.static() {
435 sanitizers = append(sanitizers, "unsigned-integer-overflow")
436 sanitizers = append(sanitizers, "signed-integer-overflow")
437 flags.CFlags = append(flags.CFlags, intOverflowCflags...)
438 if Bool(sanitize.Properties.Sanitize.Diag.Integer_overflow) {
439 diagSanitizers = append(diagSanitizers, "unsigned-integer-overflow")
440 diagSanitizers = append(diagSanitizers, "signed-integer-overflow")
441 }
442 }
443 }
444
Colin Cross16b23492016-01-06 14:41:07 -0800445 if len(sanitizers) > 0 {
446 sanitizeArg := "-fsanitize=" + strings.Join(sanitizers, ",")
Ivan Lozano954f4302018-02-21 15:49:20 -0800447
Colin Cross16b23492016-01-06 14:41:07 -0800448 flags.CFlags = append(flags.CFlags, sanitizeArg)
449 if ctx.Host() {
450 flags.CFlags = append(flags.CFlags, "-fno-sanitize-recover=all")
451 flags.LdFlags = append(flags.LdFlags, sanitizeArg)
Evgenii Stepanov76cee232017-01-27 15:44:44 -0800452 // Host sanitizers only link symbols in the final executable, so
453 // there will always be undefined symbols in intermediate libraries.
454 _, flags.LdFlags = removeFromList("-Wl,--no-undefined", flags.LdFlags)
Colin Cross16b23492016-01-06 14:41:07 -0800455 } else {
Colin Cross263abbd2016-07-15 13:10:48 -0700456 flags.CFlags = append(flags.CFlags, "-fsanitize-trap=all", "-ftrap-function=abort")
Ivan Lozano954f4302018-02-21 15:49:20 -0800457
458 if enableMinimalRuntime(sanitize) {
459 flags.CFlags = append(flags.CFlags, strings.Join(minimalRuntimeFlags, " "))
460 flags.libFlags = append([]string{minimalRuntimePath}, flags.libFlags...)
Ivan Lozano1838ef92018-05-10 14:17:22 -0700461 flags.LdFlags = append(flags.LdFlags, "-Wl,--exclude-libs,"+minimalRuntimeLib)
Ivan Lozano954f4302018-02-21 15:49:20 -0800462 }
Colin Cross16b23492016-01-06 14:41:07 -0800463 }
464 }
465
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700466 if len(diagSanitizers) > 0 {
Ivan Lozanob7d0f522018-01-20 01:44:38 +0000467 flags.CFlags = append(flags.CFlags, "-fno-sanitize-trap="+strings.Join(diagSanitizers, ","))
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700468 }
469 // FIXME: enable RTTI if diag + (cfi or vptr)
470
Andreas Gampe97071162017-05-08 13:15:23 -0700471 if sanitize.Properties.Sanitize.Recover != nil {
472 flags.CFlags = append(flags.CFlags, "-fsanitize-recover="+
473 strings.Join(sanitize.Properties.Sanitize.Recover, ","))
474 }
475
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700476 // Link a runtime library if needed.
477 runtimeLibrary := ""
478 if Bool(sanitize.Properties.Sanitize.Address) {
479 runtimeLibrary = config.AddressSanitizerRuntimeLibrary(ctx.toolchain())
Yabin Cui6be405e2017-10-19 15:52:11 -0700480 } else if Bool(sanitize.Properties.Sanitize.Thread) {
481 runtimeLibrary = config.ThreadSanitizerRuntimeLibrary(ctx.toolchain())
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700482 } else if len(diagSanitizers) > 0 {
483 runtimeLibrary = config.UndefinedBehaviorSanitizerRuntimeLibrary(ctx.toolchain())
484 }
485
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700486 if runtimeLibrary != "" {
Jiyong Park27b188b2017-07-18 13:23:39 +0900487 // ASan runtime library must be the first in the link order.
Colin Cross8ff9ef42017-05-08 13:44:11 -0700488 flags.libFlags = append([]string{
489 "${config.ClangAsanLibDir}/" + runtimeLibrary + ctx.toolchain().ShlibSuffix(),
490 }, flags.libFlags...)
491 sanitize.runtimeLibrary = runtimeLibrary
Jiyong Park27b188b2017-07-18 13:23:39 +0900492
493 // When linking against VNDK, use the vendor variant of the runtime lib
494 sanitize.androidMkRuntimeLibrary = sanitize.runtimeLibrary
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700495 if ctx.useVndk() {
Jiyong Park27b188b2017-07-18 13:23:39 +0900496 sanitize.androidMkRuntimeLibrary = sanitize.runtimeLibrary + vendorSuffix
497 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700498 }
499
Colin Cross635c3b02016-05-18 15:37:25 -0700500 blacklist := android.OptionalPathForModuleSrc(ctx, sanitize.Properties.Sanitize.Blacklist)
Colin Cross16b23492016-01-06 14:41:07 -0800501 if blacklist.Valid() {
502 flags.CFlags = append(flags.CFlags, "-fsanitize-blacklist="+blacklist.String())
503 flags.CFlagsDeps = append(flags.CFlagsDeps, blacklist.Path())
504 }
505
506 return flags
507}
508
Colin Cross8ff9ef42017-05-08 13:44:11 -0700509func (sanitize *sanitize) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) {
Colin Cross27a4b052017-08-10 16:32:23 -0700510 ret.Extra = append(ret.Extra, func(w io.Writer, outputFile android.Path) {
Jiyong Park27b188b2017-07-18 13:23:39 +0900511 if sanitize.androidMkRuntimeLibrary != "" {
512 fmt.Fprintln(w, "LOCAL_SHARED_LIBRARIES += "+sanitize.androidMkRuntimeLibrary)
Colin Cross8ff9ef42017-05-08 13:44:11 -0700513 }
Colin Cross8ff9ef42017-05-08 13:44:11 -0700514 })
Vishwath Mohane7128792017-11-17 11:08:10 -0800515
516 // Add a suffix for CFI-enabled static libraries to allow surfacing both to make without a
517 // name conflict.
518 if ret.Class == "STATIC_LIBRARIES" && Bool(sanitize.Properties.Sanitize.Cfi) {
519 ret.SubName += ".cfi"
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000520 }
Colin Cross8ff9ef42017-05-08 13:44:11 -0700521}
522
Vishwath Mohan1dd88392017-03-29 22:00:18 -0700523func (sanitize *sanitize) inSanitizerDir() bool {
524 return sanitize.Properties.InSanitizerDir
Colin Cross30d5f512016-05-03 18:02:42 -0700525}
526
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000527func (sanitize *sanitize) getSanitizerBoolPtr(t sanitizerType) *bool {
Vishwath Mohan95229302017-08-11 00:53:16 +0000528 switch t {
529 case asan:
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000530 return sanitize.Properties.Sanitize.Address
Vishwath Mohan95229302017-08-11 00:53:16 +0000531 case tsan:
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000532 return sanitize.Properties.Sanitize.Thread
Vishwath Mohan95229302017-08-11 00:53:16 +0000533 case intOverflow:
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000534 return sanitize.Properties.Sanitize.Integer_overflow
535 case cfi:
536 return sanitize.Properties.Sanitize.Cfi
Vishwath Mohan95229302017-08-11 00:53:16 +0000537 default:
538 panic(fmt.Errorf("unknown sanitizerType %d", t))
539 }
540}
541
Dan Albert7d1eecf2018-01-19 12:30:45 -0800542func (sanitize *sanitize) isUnsanitizedVariant() bool {
543 return !sanitize.isSanitizerEnabled(asan) &&
544 !sanitize.isSanitizerEnabled(tsan) &&
545 !sanitize.isSanitizerEnabled(cfi)
546}
547
Jayant Chowdharyf267f712018-05-10 15:29:24 -0700548func (sanitize *sanitize) isVariantOnProductionDevice() bool {
549 return !sanitize.isSanitizerEnabled(asan) &&
550 !sanitize.isSanitizerEnabled(tsan)
551}
552
Colin Cross16b23492016-01-06 14:41:07 -0800553func (sanitize *sanitize) SetSanitizer(t sanitizerType, b bool) {
554 switch t {
555 case asan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700556 sanitize.Properties.Sanitize.Address = boolPtr(b)
Colin Cross91169fe2016-08-11 15:54:20 -0700557 if !b {
558 sanitize.Properties.Sanitize.Coverage = nil
559 }
Colin Cross16b23492016-01-06 14:41:07 -0800560 case tsan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700561 sanitize.Properties.Sanitize.Thread = boolPtr(b)
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700562 case intOverflow:
563 sanitize.Properties.Sanitize.Integer_overflow = boolPtr(b)
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000564 case cfi:
565 sanitize.Properties.Sanitize.Cfi = boolPtr(b)
566 sanitize.Properties.Sanitize.Diag.Cfi = boolPtr(b)
Colin Cross16b23492016-01-06 14:41:07 -0800567 default:
568 panic(fmt.Errorf("unknown sanitizerType %d", t))
569 }
570 if b {
571 sanitize.Properties.SanitizerEnabled = true
572 }
573}
574
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000575// Check if the sanitizer is explicitly disabled (as opposed to nil by
576// virtue of not being set).
577func (sanitize *sanitize) isSanitizerExplicitlyDisabled(t sanitizerType) bool {
578 if sanitize == nil {
579 return false
580 }
581
582 sanitizerVal := sanitize.getSanitizerBoolPtr(t)
583 return sanitizerVal != nil && *sanitizerVal == false
584}
585
586// There isn't an analog of the method above (ie:isSanitizerExplicitlyEnabled)
587// because enabling a sanitizer either directly (via the blueprint) or
588// indirectly (via a mutator) sets the bool ptr to true, and you can't
589// distinguish between the cases. It isn't needed though - both cases can be
590// treated identically.
591func (sanitize *sanitize) isSanitizerEnabled(t sanitizerType) bool {
592 if sanitize == nil {
593 return false
594 }
595
596 sanitizerVal := sanitize.getSanitizerBoolPtr(t)
597 return sanitizerVal != nil && *sanitizerVal == true
598}
599
Colin Cross16b23492016-01-06 14:41:07 -0800600// Propagate asan requirements down from binaries
Colin Cross635c3b02016-05-18 15:37:25 -0700601func sanitizerDepsMutator(t sanitizerType) func(android.TopDownMutatorContext) {
602 return func(mctx android.TopDownMutatorContext) {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000603 if c, ok := mctx.Module().(*Module); ok && c.sanitize.isSanitizerEnabled(t) {
Colin Crossd11fcda2017-10-23 17:59:01 -0700604 mctx.VisitDepsDepthFirst(func(module android.Module) {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000605 if d, ok := module.(*Module); ok && d.sanitize != nil &&
Nan Zhang0007d812017-11-07 10:57:05 -0800606 !Bool(d.sanitize.Properties.Sanitize.Never) &&
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000607 !d.sanitize.isSanitizerExplicitlyDisabled(t) {
608 if (t == cfi && d.static()) || t != cfi {
609 d.sanitize.Properties.SanitizeDep = true
610 }
Colin Cross16b23492016-01-06 14:41:07 -0800611 }
612 })
613 }
614 }
615}
616
Ivan Lozano954f4302018-02-21 15:49:20 -0800617// Propagate the ubsan minimal runtime dependency when there are integer overflow sanitized static dependencies.
618func minimalRuntimeDepsMutator() func(android.TopDownMutatorContext) {
619 return func(mctx android.TopDownMutatorContext) {
620 if c, ok := mctx.Module().(*Module); ok && c.sanitize != nil {
621 mctx.VisitDepsDepthFirst(func(module android.Module) {
622 if d, ok := module.(*Module); ok && d.static() && d.sanitize != nil {
623
624 // If a static dependency will be built with the minimal runtime,
625 // make sure we include the ubsan minimal runtime.
626 if enableMinimalRuntime(d.sanitize) {
627 c.sanitize.Properties.MinimalRuntimeDep = true
628 }
629 }
630 })
631 }
632 }
633}
634
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000635// Create sanitized variants for modules that need them
Colin Cross635c3b02016-05-18 15:37:25 -0700636func sanitizerMutator(t sanitizerType) func(android.BottomUpMutatorContext) {
637 return func(mctx android.BottomUpMutatorContext) {
Vishwath Mohane6153452017-08-11 00:52:44 +0000638 if c, ok := mctx.Module().(*Module); ok && c.sanitize != nil {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000639 if c.isDependencyRoot() && c.sanitize.isSanitizerEnabled(t) {
Colin Cross30d5f512016-05-03 18:02:42 -0700640 modules := mctx.CreateVariations(t.String())
641 modules[0].(*Module).sanitize.SetSanitizer(t, true)
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000642 } else if c.sanitize.isSanitizerEnabled(t) || c.sanitize.Properties.SanitizeDep {
643 // Save original sanitizer status before we assign values to variant
644 // 0 as that overwrites the original.
645 isSanitizerEnabled := c.sanitize.isSanitizerEnabled(t)
646
Colin Crossb0f28952016-09-19 16:46:53 -0700647 modules := mctx.CreateVariations("", t.String())
648 modules[0].(*Module).sanitize.SetSanitizer(t, false)
649 modules[1].(*Module).sanitize.SetSanitizer(t, true)
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000650
Colin Crossb0f28952016-09-19 16:46:53 -0700651 modules[0].(*Module).sanitize.Properties.SanitizeDep = false
652 modules[1].(*Module).sanitize.Properties.SanitizeDep = false
Vishwath Mohane7128792017-11-17 11:08:10 -0800653
654 // We don't need both variants active for anything but CFI-enabled
655 // target static libraries, so suppress the appropriate variant in
656 // all other cases.
657 if t == cfi {
658 if c.static() {
659 if !mctx.Device() {
660 if isSanitizerEnabled {
661 modules[0].(*Module).Properties.PreventInstall = true
662 modules[0].(*Module).Properties.HideFromMake = true
663 } else {
664 modules[1].(*Module).Properties.PreventInstall = true
665 modules[1].(*Module).Properties.HideFromMake = true
666 }
667 } else {
Colin Cross6510f912017-11-29 00:27:14 -0800668 cfiStaticLibs := cfiStaticLibs(mctx.Config())
Vishwath Mohane7128792017-11-17 11:08:10 -0800669
670 cfiStaticLibsMutex.Lock()
671 *cfiStaticLibs = append(*cfiStaticLibs, c.Name())
672 cfiStaticLibsMutex.Unlock()
673 }
674 } else {
675 modules[0].(*Module).Properties.PreventInstall = true
676 modules[0].(*Module).Properties.HideFromMake = true
677 }
678 } else if t == asan {
679 if mctx.Device() {
680 // CFI and ASAN are currently mutually exclusive so disable
681 // CFI if this is an ASAN variant.
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000682 modules[1].(*Module).sanitize.Properties.InSanitizerDir = true
683 modules[1].(*Module).sanitize.SetSanitizer(cfi, false)
684 }
Vishwath Mohane21fe422017-11-01 19:42:45 -0700685 if isSanitizerEnabled {
686 modules[0].(*Module).Properties.PreventInstall = true
Vishwath Mohane7128792017-11-17 11:08:10 -0800687 modules[0].(*Module).Properties.HideFromMake = true
Vishwath Mohane21fe422017-11-01 19:42:45 -0700688 } else {
689 modules[1].(*Module).Properties.PreventInstall = true
Vishwath Mohane7128792017-11-17 11:08:10 -0800690 modules[1].(*Module).Properties.HideFromMake = true
Vishwath Mohane21fe422017-11-01 19:42:45 -0700691 }
692 }
Colin Cross16b23492016-01-06 14:41:07 -0800693 }
694 c.sanitize.Properties.SanitizeDep = false
695 }
696 }
697}
Vishwath Mohane7128792017-11-17 11:08:10 -0800698
699func cfiStaticLibs(config android.Config) *[]string {
700 return config.Once("cfiStaticLibs", func() interface{} {
701 return &[]string{}
702 }).(*[]string)
703}
704
Ivan Lozano954f4302018-02-21 15:49:20 -0800705func enableMinimalRuntime(sanitize *sanitize) bool {
706 if !Bool(sanitize.Properties.Sanitize.Address) &&
707 (Bool(sanitize.Properties.Sanitize.Integer_overflow) ||
708 len(sanitize.Properties.Sanitize.Misc_undefined) > 0) &&
709 !(Bool(sanitize.Properties.Sanitize.Diag.Integer_overflow) ||
710 Bool(sanitize.Properties.Sanitize.Diag.Cfi) ||
711 len(sanitize.Properties.Sanitize.Diag.Misc_undefined) > 0) {
712 return true
713 }
714 return false
715}
716
Vishwath Mohane7128792017-11-17 11:08:10 -0800717func cfiMakeVarsProvider(ctx android.MakeVarsContext) {
718 cfiStaticLibs := cfiStaticLibs(ctx.Config())
Jeff Gaston72765392017-11-28 16:37:53 -0800719 sort.Strings(*cfiStaticLibs)
Vishwath Mohane7128792017-11-17 11:08:10 -0800720 ctx.Strict("SOONG_CFI_STATIC_LIBRARIES", strings.Join(*cfiStaticLibs, " "))
721}