blob: 447c5b42cef458ab08bdf4bf7782ae0cb8f7ca9a [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"
19 "strings"
20
21 "github.com/google/blueprint"
22
Colin Cross635c3b02016-05-18 15:37:25 -070023 "android/soong/android"
Evgenii Stepanovaf36db12016-08-15 14:18:24 -070024 "android/soong/cc/config"
Colin Cross16b23492016-01-06 14:41:07 -080025)
26
Dan Willemsencbceaab2016-10-13 16:44:07 -070027const (
Dan Willemsen78ffeea2016-10-20 18:46:48 -070028 asanCflags = "-fno-omit-frame-pointer"
Dan Willemsencbceaab2016-10-13 16:44:07 -070029 asanLdflags = "-Wl,-u,__asan_preinit"
Dan Willemsen78ffeea2016-10-20 18:46:48 -070030 asanLibs = "libasan"
Dan Willemsencbceaab2016-10-13 16:44:07 -070031)
32
Colin Cross16b23492016-01-06 14:41:07 -080033type sanitizerType int
34
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070035func boolPtr(v bool) *bool {
36 if v {
37 return &v
38 } else {
39 return nil
40 }
41}
42
Colin Cross16b23492016-01-06 14:41:07 -080043const (
44 asan sanitizerType = iota + 1
45 tsan
46)
47
48func (t sanitizerType) String() string {
49 switch t {
50 case asan:
51 return "asan"
52 case tsan:
53 return "tsan"
54 default:
55 panic(fmt.Errorf("unknown sanitizerType %d", t))
56 }
57}
58
59type SanitizeProperties struct {
60 // enable AddressSanitizer, ThreadSanitizer, or UndefinedBehaviorSanitizer
61 Sanitize struct {
62 Never bool `android:"arch_variant"`
63
64 // main sanitizers
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070065 Address *bool `android:"arch_variant"`
66 Thread *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080067
68 // local sanitizers
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070069 Undefined *bool `android:"arch_variant"`
70 All_undefined *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080071 Misc_undefined []string `android:"arch_variant"`
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070072 Coverage *bool `android:"arch_variant"`
73 Safestack *bool `android:"arch_variant"`
Evgenii Stepanov1e405e12016-08-16 15:39:54 -070074 Cfi *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080075
Evgenii Stepanov1e405e12016-08-16 15:39:54 -070076 // Sanitizers to run in the diagnostic mode (as opposed to the release mode).
77 // Replaces abort() on error with a human-readable error message.
78 // Address and Thread sanitizers always run in diagnostic mode.
79 Diag struct {
80 Undefined *bool `android:"arch_variant"`
81 Cfi *bool `android:"arch_variant"`
82 }
83
84 // value to pass to -fsanitize-recover=
Colin Cross16b23492016-01-06 14:41:07 -080085 Recover []string
86
87 // value to pass to -fsanitize-blacklist
88 Blacklist *string
89 } `android:"arch_variant"`
90
91 SanitizerEnabled bool `blueprint:"mutated"`
92 SanitizeDep bool `blueprint:"mutated"`
Colin Cross30d5f512016-05-03 18:02:42 -070093 InData bool `blueprint:"mutated"`
Colin Cross16b23492016-01-06 14:41:07 -080094}
95
96type sanitize struct {
97 Properties SanitizeProperties
98}
99
100func (sanitize *sanitize) props() []interface{} {
101 return []interface{}{&sanitize.Properties}
102}
103
104func (sanitize *sanitize) begin(ctx BaseModuleContext) {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700105 s := &sanitize.Properties.Sanitize
106
Colin Cross16b23492016-01-06 14:41:07 -0800107 // Don't apply sanitizers to NDK code.
108 if ctx.sdk() {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700109 s.Never = true
Colin Cross16b23492016-01-06 14:41:07 -0800110 }
111
112 // Never always wins.
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700113 if s.Never {
Colin Cross16b23492016-01-06 14:41:07 -0800114 return
115 }
116
Colin Cross16b23492016-01-06 14:41:07 -0800117 var globalSanitizers []string
118 if ctx.clang() {
119 if ctx.Host() {
120 globalSanitizers = ctx.AConfig().SanitizeHost()
121 } else {
Colin Cross23ae82a2016-11-02 14:34:39 -0700122 arches := ctx.AConfig().SanitizeDeviceArch()
123 if len(arches) == 0 || inList(ctx.Arch().ArchType.Name, arches) {
124 globalSanitizers = ctx.AConfig().SanitizeDevice()
125 }
Colin Cross16b23492016-01-06 14:41:07 -0800126 }
127 }
128
Colin Cross16b23492016-01-06 14:41:07 -0800129 if len(globalSanitizers) > 0 {
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000130 var found bool
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700131 if found, globalSanitizers = removeFromList("undefined", globalSanitizers); found && s.All_undefined == nil {
132 s.All_undefined = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000133 }
Colin Cross16b23492016-01-06 14:41:07 -0800134
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700135 if found, globalSanitizers = removeFromList("default-ub", globalSanitizers); found && s.Undefined == nil {
136 s.Undefined = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000137 }
138
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700139 if found, globalSanitizers = removeFromList("address", globalSanitizers); found && s.Address == nil {
140 s.Address = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000141 }
142
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700143 if found, globalSanitizers = removeFromList("thread", globalSanitizers); found && s.Thread == nil {
144 s.Thread = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000145 }
146
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700147 if found, globalSanitizers = removeFromList("coverage", globalSanitizers); found && s.Coverage == nil {
148 s.Coverage = boolPtr(true)
149 }
150
151 if found, globalSanitizers = removeFromList("safe-stack", globalSanitizers); found && s.Safestack == nil {
152 s.Safestack = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000153 }
154
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700155 if found, globalSanitizers = removeFromList("cfi", globalSanitizers); found && s.Cfi == nil {
156 s.Cfi = boolPtr(true)
157 }
158
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000159 if len(globalSanitizers) > 0 {
160 ctx.ModuleErrorf("unknown global sanitizer option %s", globalSanitizers[0])
161 }
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700162 }
Colin Cross3c344ef2016-07-18 15:44:56 -0700163
164 if ctx.staticBinary() {
165 s.Address = nil
Colin Cross91169fe2016-08-11 15:54:20 -0700166 s.Coverage = nil
Colin Cross3c344ef2016-07-18 15:44:56 -0700167 s.Thread = nil
Colin Cross16b23492016-01-06 14:41:07 -0800168 }
169
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700170 if Bool(s.All_undefined) {
171 s.Undefined = nil
172 }
173
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700174 if !ctx.toolchain().Is64Bit() {
175 // TSAN and SafeStack are not supported on 32-bit architectures
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700176 s.Thread = nil
177 s.Safestack = nil
Colin Cross16b23492016-01-06 14:41:07 -0800178 // TODO(ccross): error for compile_multilib = "32"?
179 }
180
Colin Cross3c344ef2016-07-18 15:44:56 -0700181 if Bool(s.All_undefined) || Bool(s.Undefined) || Bool(s.Address) ||
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700182 Bool(s.Thread) || Bool(s.Coverage) || Bool(s.Safestack) || Bool(s.Cfi) {
Colin Cross3c344ef2016-07-18 15:44:56 -0700183 sanitize.Properties.SanitizerEnabled = true
184 }
185
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700186 if Bool(s.Coverage) {
187 if !Bool(s.Address) {
Colin Cross16b23492016-01-06 14:41:07 -0800188 ctx.ModuleErrorf(`Use of "coverage" also requires "address"`)
189 }
190 }
191}
192
193func (sanitize *sanitize) deps(ctx BaseModuleContext, deps Deps) Deps {
194 if !sanitize.Properties.SanitizerEnabled { // || c.static() {
195 return deps
196 }
197
198 if ctx.Device() {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700199 if Bool(sanitize.Properties.Sanitize.Address) {
Dan Willemsencbceaab2016-10-13 16:44:07 -0700200 deps.StaticLibs = append(deps.StaticLibs, asanLibs)
Colin Cross16b23492016-01-06 14:41:07 -0800201 }
Colin Cross263abbd2016-07-15 13:10:48 -0700202 if Bool(sanitize.Properties.Sanitize.Address) || Bool(sanitize.Properties.Sanitize.Thread) {
203 deps.SharedLibs = append(deps.SharedLibs, "libdl")
204 }
Colin Cross16b23492016-01-06 14:41:07 -0800205 }
206
207 return deps
208}
209
210func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags) Flags {
211 if !sanitize.Properties.SanitizerEnabled {
212 return flags
213 }
214
215 if !ctx.clang() {
216 ctx.ModuleErrorf("Use of sanitizers requires clang")
217 }
218
219 var sanitizers []string
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700220 var diagSanitizers []string
Colin Cross16b23492016-01-06 14:41:07 -0800221
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700222 if Bool(sanitize.Properties.Sanitize.All_undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800223 sanitizers = append(sanitizers, "undefined")
224 if ctx.Device() {
225 ctx.ModuleErrorf("ubsan is not yet supported on the device")
226 }
227 } else {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700228 if Bool(sanitize.Properties.Sanitize.Undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800229 sanitizers = append(sanitizers,
230 "bool",
231 "integer-divide-by-zero",
232 "return",
233 "returns-nonnull-attribute",
234 "shift-exponent",
235 "unreachable",
236 "vla-bound",
237 // TODO(danalbert): The following checks currently have compiler performance issues.
238 //"alignment",
239 //"bounds",
240 //"enum",
241 //"float-cast-overflow",
242 //"float-divide-by-zero",
243 //"nonnull-attribute",
244 //"null",
245 //"shift-base",
246 //"signed-integer-overflow",
247 // TODO(danalbert): Fix UB in libc++'s __tree so we can turn this on.
248 // https://llvm.org/PR19302
249 // http://reviews.llvm.org/D6974
250 // "object-size",
251 )
252 }
253 sanitizers = append(sanitizers, sanitize.Properties.Sanitize.Misc_undefined...)
254 }
255
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700256 if Bool(sanitize.Properties.Sanitize.Diag.Undefined) &&
257 (Bool(sanitize.Properties.Sanitize.All_undefined) ||
258 Bool(sanitize.Properties.Sanitize.Undefined) ||
259 len(sanitize.Properties.Sanitize.Misc_undefined) > 0) {
260 diagSanitizers = append(diagSanitizers, "undefined")
261 }
262
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700263 if Bool(sanitize.Properties.Sanitize.Address) {
Colin Cross635c3b02016-05-18 15:37:25 -0700264 if ctx.Arch().ArchType == android.Arm {
Colin Cross16b23492016-01-06 14:41:07 -0800265 // Frame pointer based unwinder in ASan requires ARM frame setup.
266 // TODO: put in flags?
267 flags.RequiredInstructionSet = "arm"
268 }
Dan Willemsencbceaab2016-10-13 16:44:07 -0700269 flags.CFlags = append(flags.CFlags, asanCflags)
270 flags.LdFlags = append(flags.LdFlags, asanLdflags)
Colin Cross16b23492016-01-06 14:41:07 -0800271
272 // ASan runtime library must be the first in the link order.
Evgenii Stepanovaf36db12016-08-15 14:18:24 -0700273 runtimeLibrary := config.AddressSanitizerRuntimeLibrary(ctx.toolchain())
Colin Cross16b23492016-01-06 14:41:07 -0800274 if runtimeLibrary != "" {
Colin Crossb98c8b02016-07-29 13:44:28 -0700275 flags.libFlags = append([]string{"${config.ClangAsanLibDir}/" + runtimeLibrary}, flags.libFlags...)
Colin Cross16b23492016-01-06 14:41:07 -0800276 }
277 if ctx.Host() {
278 // -nodefaultlibs (provided with libc++) prevents the driver from linking
279 // libraries needed with -fsanitize=address. http://b/18650275 (WAI)
280 flags.LdFlags = append(flags.LdFlags, "-lm", "-lpthread")
281 flags.LdFlags = append(flags.LdFlags, "-Wl,--no-as-needed")
Colin Cross46974e22016-10-20 12:41:14 -0700282 // Host ASAN only links symbols in the final executable, so
283 // there will always be undefined symbols in intermediate libraries.
284 _, flags.LdFlags = removeFromList("-Wl,--no-undefined", flags.LdFlags)
Colin Cross16b23492016-01-06 14:41:07 -0800285 } else {
286 flags.CFlags = append(flags.CFlags, "-mllvm", "-asan-globals=0")
287 flags.DynamicLinker = "/system/bin/linker_asan"
288 if flags.Toolchain.Is64Bit() {
289 flags.DynamicLinker += "64"
290 }
291 }
292 sanitizers = append(sanitizers, "address")
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700293 diagSanitizers = append(diagSanitizers, "address")
Colin Cross16b23492016-01-06 14:41:07 -0800294 }
295
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700296 if Bool(sanitize.Properties.Sanitize.Coverage) {
Colin Cross16b23492016-01-06 14:41:07 -0800297 flags.CFlags = append(flags.CFlags, "-fsanitize-coverage=edge,indirect-calls,8bit-counters,trace-cmp")
298 }
299
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700300 if Bool(sanitize.Properties.Sanitize.Safestack) {
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700301 sanitizers = append(sanitizers, "safe-stack")
302 }
303
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700304 if Bool(sanitize.Properties.Sanitize.Cfi) {
305 sanitizers = append(sanitizers, "cfi")
306 cfiFlags := []string{"-flto", "-fsanitize=cfi", "-fsanitize-cfi-cross-dso"}
307 flags.CFlags = append(flags.CFlags, cfiFlags...)
308 flags.CFlags = append(flags.CFlags, "-fvisibility=default")
309 flags.LdFlags = append(flags.LdFlags, cfiFlags...)
310 // FIXME: revert the __cfi_check flag when clang is updated to r280031.
311 flags.LdFlags = append(flags.LdFlags, "-Wl,-plugin-opt,O1", "-Wl,-export-dynamic-symbol=__cfi_check")
312 if Bool(sanitize.Properties.Sanitize.Diag.Cfi) {
313 diagSanitizers = append(diagSanitizers, "cfi")
314 }
315 }
316
Colin Cross16b23492016-01-06 14:41:07 -0800317 if sanitize.Properties.Sanitize.Recover != nil {
318 flags.CFlags = append(flags.CFlags, "-fsanitize-recover="+
319 strings.Join(sanitize.Properties.Sanitize.Recover, ","))
320 }
321
322 if len(sanitizers) > 0 {
323 sanitizeArg := "-fsanitize=" + strings.Join(sanitizers, ",")
324 flags.CFlags = append(flags.CFlags, sanitizeArg)
325 if ctx.Host() {
326 flags.CFlags = append(flags.CFlags, "-fno-sanitize-recover=all")
327 flags.LdFlags = append(flags.LdFlags, sanitizeArg)
328 flags.LdFlags = append(flags.LdFlags, "-lrt", "-ldl")
329 } else {
Colin Cross263abbd2016-07-15 13:10:48 -0700330 flags.CFlags = append(flags.CFlags, "-fsanitize-trap=all", "-ftrap-function=abort")
Colin Cross16b23492016-01-06 14:41:07 -0800331 }
332 }
333
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700334 if len(diagSanitizers) > 0 {
335 flags.CFlags = append(flags.CFlags, "-fno-sanitize-trap="+strings.Join(diagSanitizers, ","))
336 }
337 // FIXME: enable RTTI if diag + (cfi or vptr)
338
339 // Link a runtime library if needed.
340 runtimeLibrary := ""
341 if Bool(sanitize.Properties.Sanitize.Address) {
342 runtimeLibrary = config.AddressSanitizerRuntimeLibrary(ctx.toolchain())
343 } else if len(diagSanitizers) > 0 {
344 runtimeLibrary = config.UndefinedBehaviorSanitizerRuntimeLibrary(ctx.toolchain())
345 }
346
347 // ASan runtime library must be the first in the link order.
348 if runtimeLibrary != "" {
349 flags.libFlags = append([]string{"${config.ClangAsanLibDir}/" + runtimeLibrary}, flags.libFlags...)
350 }
351
Colin Cross635c3b02016-05-18 15:37:25 -0700352 blacklist := android.OptionalPathForModuleSrc(ctx, sanitize.Properties.Sanitize.Blacklist)
Colin Cross16b23492016-01-06 14:41:07 -0800353 if blacklist.Valid() {
354 flags.CFlags = append(flags.CFlags, "-fsanitize-blacklist="+blacklist.String())
355 flags.CFlagsDeps = append(flags.CFlagsDeps, blacklist.Path())
356 }
357
358 return flags
359}
360
Colin Cross30d5f512016-05-03 18:02:42 -0700361func (sanitize *sanitize) inData() bool {
362 return sanitize.Properties.InData
363}
364
Colin Cross16b23492016-01-06 14:41:07 -0800365func (sanitize *sanitize) Sanitizer(t sanitizerType) bool {
366 if sanitize == nil {
367 return false
368 }
369
370 switch t {
371 case asan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700372 return Bool(sanitize.Properties.Sanitize.Address)
Colin Cross16b23492016-01-06 14:41:07 -0800373 case tsan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700374 return Bool(sanitize.Properties.Sanitize.Thread)
Colin Cross16b23492016-01-06 14:41:07 -0800375 default:
376 panic(fmt.Errorf("unknown sanitizerType %d", t))
377 }
378}
379
380func (sanitize *sanitize) SetSanitizer(t sanitizerType, b bool) {
381 switch t {
382 case asan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700383 sanitize.Properties.Sanitize.Address = boolPtr(b)
Colin Cross91169fe2016-08-11 15:54:20 -0700384 if !b {
385 sanitize.Properties.Sanitize.Coverage = nil
386 }
Colin Cross16b23492016-01-06 14:41:07 -0800387 case tsan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700388 sanitize.Properties.Sanitize.Thread = boolPtr(b)
Colin Cross16b23492016-01-06 14:41:07 -0800389 default:
390 panic(fmt.Errorf("unknown sanitizerType %d", t))
391 }
392 if b {
393 sanitize.Properties.SanitizerEnabled = true
394 }
395}
396
397// Propagate asan requirements down from binaries
Colin Cross635c3b02016-05-18 15:37:25 -0700398func sanitizerDepsMutator(t sanitizerType) func(android.TopDownMutatorContext) {
399 return func(mctx android.TopDownMutatorContext) {
Colin Cross16b23492016-01-06 14:41:07 -0800400 if c, ok := mctx.Module().(*Module); ok && c.sanitize.Sanitizer(t) {
401 mctx.VisitDepsDepthFirst(func(module blueprint.Module) {
402 if d, ok := mctx.Module().(*Module); ok && c.sanitize != nil &&
403 !c.sanitize.Properties.Sanitize.Never {
404 d.sanitize.Properties.SanitizeDep = true
405 }
406 })
407 }
408 }
409}
410
411// Create asan variants for modules that need them
Colin Cross635c3b02016-05-18 15:37:25 -0700412func sanitizerMutator(t sanitizerType) func(android.BottomUpMutatorContext) {
413 return func(mctx android.BottomUpMutatorContext) {
Colin Cross16b23492016-01-06 14:41:07 -0800414 if c, ok := mctx.Module().(*Module); ok && c.sanitize != nil {
Colin Crossb916a382016-07-29 17:28:03 -0700415 if c.isDependencyRoot() && c.sanitize.Sanitizer(t) {
Colin Cross30d5f512016-05-03 18:02:42 -0700416 modules := mctx.CreateVariations(t.String())
417 modules[0].(*Module).sanitize.SetSanitizer(t, true)
Colin Cross16b23492016-01-06 14:41:07 -0800418 } else if c.sanitize.Properties.SanitizeDep {
Colin Crossb0f28952016-09-19 16:46:53 -0700419 modules := mctx.CreateVariations("", t.String())
420 modules[0].(*Module).sanitize.SetSanitizer(t, false)
421 modules[1].(*Module).sanitize.SetSanitizer(t, true)
422 modules[0].(*Module).sanitize.Properties.SanitizeDep = false
423 modules[1].(*Module).sanitize.Properties.SanitizeDep = false
424 if mctx.Device() {
Colin Crossb36ab1a2016-05-25 12:35:53 -0700425 modules[1].(*Module).sanitize.Properties.InData = true
Colin Crossb0f28952016-09-19 16:46:53 -0700426 } else {
427 modules[0].(*Module).Properties.PreventInstall = true
428 }
429 if mctx.AConfig().EmbeddedInMake() {
430 modules[0].(*Module).Properties.HideFromMake = true
Colin Cross30d5f512016-05-03 18:02:42 -0700431 }
Colin Cross16b23492016-01-06 14:41:07 -0800432 }
433 c.sanitize.Properties.SanitizeDep = false
434 }
435 }
436}