blob: 76d6618eaf73fb0b170d41d047f53ad94fcf6dda [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"
Colin Cross16b23492016-01-06 14:41:07 -080024)
25
26type sanitizerType int
27
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070028func boolPtr(v bool) *bool {
29 if v {
30 return &v
31 } else {
32 return nil
33 }
34}
35
Colin Cross16b23492016-01-06 14:41:07 -080036func init() {
37 pctx.StaticVariable("clangAsanLibDir", "${clangPath}/lib64/clang/3.8/lib/linux")
38}
39
40const (
41 asan sanitizerType = iota + 1
42 tsan
43)
44
45func (t sanitizerType) String() string {
46 switch t {
47 case asan:
48 return "asan"
49 case tsan:
50 return "tsan"
51 default:
52 panic(fmt.Errorf("unknown sanitizerType %d", t))
53 }
54}
55
56type SanitizeProperties struct {
57 // enable AddressSanitizer, ThreadSanitizer, or UndefinedBehaviorSanitizer
58 Sanitize struct {
59 Never bool `android:"arch_variant"`
60
61 // main sanitizers
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070062 Address *bool `android:"arch_variant"`
63 Thread *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080064
65 // local sanitizers
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070066 Undefined *bool `android:"arch_variant"`
67 All_undefined *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080068 Misc_undefined []string `android:"arch_variant"`
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070069 Coverage *bool `android:"arch_variant"`
70 Safestack *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080071
72 // value to pass to -fsantitize-recover=
73 Recover []string
74
75 // value to pass to -fsanitize-blacklist
76 Blacklist *string
77 } `android:"arch_variant"`
78
79 SanitizerEnabled bool `blueprint:"mutated"`
80 SanitizeDep bool `blueprint:"mutated"`
Colin Cross30d5f512016-05-03 18:02:42 -070081 InData bool `blueprint:"mutated"`
Colin Cross16b23492016-01-06 14:41:07 -080082}
83
84type sanitize struct {
85 Properties SanitizeProperties
86}
87
88func (sanitize *sanitize) props() []interface{} {
89 return []interface{}{&sanitize.Properties}
90}
91
92func (sanitize *sanitize) begin(ctx BaseModuleContext) {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070093 s := &sanitize.Properties.Sanitize
94
Colin Cross16b23492016-01-06 14:41:07 -080095 // Don't apply sanitizers to NDK code.
96 if ctx.sdk() {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070097 s.Never = true
Colin Cross16b23492016-01-06 14:41:07 -080098 }
99
100 // Never always wins.
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700101 if s.Never {
Colin Cross16b23492016-01-06 14:41:07 -0800102 return
103 }
104
Colin Cross16b23492016-01-06 14:41:07 -0800105 var globalSanitizers []string
106 if ctx.clang() {
107 if ctx.Host() {
108 globalSanitizers = ctx.AConfig().SanitizeHost()
109 } else {
110 globalSanitizers = ctx.AConfig().SanitizeDevice()
111 }
112 }
113
Colin Cross16b23492016-01-06 14:41:07 -0800114 if len(globalSanitizers) > 0 {
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000115 var found bool
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700116 if found, globalSanitizers = removeFromList("undefined", globalSanitizers); found && s.All_undefined == nil {
117 s.All_undefined = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000118 }
Colin Cross16b23492016-01-06 14:41:07 -0800119
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700120 if found, globalSanitizers = removeFromList("default-ub", globalSanitizers); found && s.Undefined == nil {
121 s.Undefined = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000122 }
123
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700124 if found, globalSanitizers = removeFromList("address", globalSanitizers); found && s.Address == nil {
125 s.Address = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000126 }
127
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700128 if found, globalSanitizers = removeFromList("thread", globalSanitizers); found && s.Thread == nil {
129 s.Thread = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000130 }
131
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700132 if found, globalSanitizers = removeFromList("coverage", globalSanitizers); found && s.Coverage == nil {
133 s.Coverage = boolPtr(true)
134 }
135
136 if found, globalSanitizers = removeFromList("safe-stack", globalSanitizers); found && s.Safestack == nil {
137 s.Safestack = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000138 }
139
140 if len(globalSanitizers) > 0 {
141 ctx.ModuleErrorf("unknown global sanitizer option %s", globalSanitizers[0])
142 }
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700143 }
144 if Bool(s.All_undefined) || Bool(s.Undefined) || Bool(s.Address) ||
145 Bool(s.Thread) || Bool(s.Coverage) || Bool(s.Safestack) {
Colin Cross16b23492016-01-06 14:41:07 -0800146 sanitize.Properties.SanitizerEnabled = true
147 }
148
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700149 if Bool(s.All_undefined) {
150 s.Undefined = nil
151 }
152
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700153 if !ctx.toolchain().Is64Bit() {
154 // TSAN and SafeStack are not supported on 32-bit architectures
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700155 s.Thread = nil
156 s.Safestack = nil
Colin Cross16b23492016-01-06 14:41:07 -0800157 // TODO(ccross): error for compile_multilib = "32"?
158 }
159
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700160 if Bool(s.Coverage) {
161 if !Bool(s.Address) {
Colin Cross16b23492016-01-06 14:41:07 -0800162 ctx.ModuleErrorf(`Use of "coverage" also requires "address"`)
163 }
164 }
165}
166
167func (sanitize *sanitize) deps(ctx BaseModuleContext, deps Deps) Deps {
168 if !sanitize.Properties.SanitizerEnabled { // || c.static() {
169 return deps
170 }
171
172 if ctx.Device() {
173 deps.SharedLibs = append(deps.SharedLibs, "libdl")
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700174 if Bool(sanitize.Properties.Sanitize.Address) {
Colin Cross16b23492016-01-06 14:41:07 -0800175 deps.StaticLibs = append(deps.StaticLibs, "libasan")
176 }
177 }
178
179 return deps
180}
181
182func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags) Flags {
183 if !sanitize.Properties.SanitizerEnabled {
184 return flags
185 }
186
187 if !ctx.clang() {
188 ctx.ModuleErrorf("Use of sanitizers requires clang")
189 }
190
191 var sanitizers []string
192
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700193 if Bool(sanitize.Properties.Sanitize.All_undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800194 sanitizers = append(sanitizers, "undefined")
195 if ctx.Device() {
196 ctx.ModuleErrorf("ubsan is not yet supported on the device")
197 }
198 } else {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700199 if Bool(sanitize.Properties.Sanitize.Undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800200 sanitizers = append(sanitizers,
201 "bool",
202 "integer-divide-by-zero",
203 "return",
204 "returns-nonnull-attribute",
205 "shift-exponent",
206 "unreachable",
207 "vla-bound",
208 // TODO(danalbert): The following checks currently have compiler performance issues.
209 //"alignment",
210 //"bounds",
211 //"enum",
212 //"float-cast-overflow",
213 //"float-divide-by-zero",
214 //"nonnull-attribute",
215 //"null",
216 //"shift-base",
217 //"signed-integer-overflow",
218 // TODO(danalbert): Fix UB in libc++'s __tree so we can turn this on.
219 // https://llvm.org/PR19302
220 // http://reviews.llvm.org/D6974
221 // "object-size",
222 )
223 }
224 sanitizers = append(sanitizers, sanitize.Properties.Sanitize.Misc_undefined...)
225 }
226
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700227 if Bool(sanitize.Properties.Sanitize.Address) {
Colin Cross635c3b02016-05-18 15:37:25 -0700228 if ctx.Arch().ArchType == android.Arm {
Colin Cross16b23492016-01-06 14:41:07 -0800229 // Frame pointer based unwinder in ASan requires ARM frame setup.
230 // TODO: put in flags?
231 flags.RequiredInstructionSet = "arm"
232 }
233 flags.CFlags = append(flags.CFlags, "-fno-omit-frame-pointer")
234 flags.LdFlags = append(flags.LdFlags, "-Wl,-u,__asan_preinit")
235
236 // ASan runtime library must be the first in the link order.
237 runtimeLibrary := ctx.toolchain().AddressSanitizerRuntimeLibrary()
238 if runtimeLibrary != "" {
239 flags.libFlags = append([]string{"${clangAsanLibDir}/" + runtimeLibrary}, flags.libFlags...)
240 }
241 if ctx.Host() {
242 // -nodefaultlibs (provided with libc++) prevents the driver from linking
243 // libraries needed with -fsanitize=address. http://b/18650275 (WAI)
244 flags.LdFlags = append(flags.LdFlags, "-lm", "-lpthread")
245 flags.LdFlags = append(flags.LdFlags, "-Wl,--no-as-needed")
246 } else {
247 flags.CFlags = append(flags.CFlags, "-mllvm", "-asan-globals=0")
248 flags.DynamicLinker = "/system/bin/linker_asan"
249 if flags.Toolchain.Is64Bit() {
250 flags.DynamicLinker += "64"
251 }
252 }
253 sanitizers = append(sanitizers, "address")
254 }
255
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700256 if Bool(sanitize.Properties.Sanitize.Coverage) {
Colin Cross16b23492016-01-06 14:41:07 -0800257 flags.CFlags = append(flags.CFlags, "-fsanitize-coverage=edge,indirect-calls,8bit-counters,trace-cmp")
258 }
259
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700260 if Bool(sanitize.Properties.Sanitize.Safestack) {
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700261 sanitizers = append(sanitizers, "safe-stack")
262 }
263
Colin Cross16b23492016-01-06 14:41:07 -0800264 if sanitize.Properties.Sanitize.Recover != nil {
265 flags.CFlags = append(flags.CFlags, "-fsanitize-recover="+
266 strings.Join(sanitize.Properties.Sanitize.Recover, ","))
267 }
268
269 if len(sanitizers) > 0 {
270 sanitizeArg := "-fsanitize=" + strings.Join(sanitizers, ",")
271 flags.CFlags = append(flags.CFlags, sanitizeArg)
272 if ctx.Host() {
273 flags.CFlags = append(flags.CFlags, "-fno-sanitize-recover=all")
274 flags.LdFlags = append(flags.LdFlags, sanitizeArg)
275 flags.LdFlags = append(flags.LdFlags, "-lrt", "-ldl")
276 } else {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700277 if !Bool(sanitize.Properties.Sanitize.Address) {
Colin Cross16b23492016-01-06 14:41:07 -0800278 flags.CFlags = append(flags.CFlags, "-fsanitize-trap=all", "-ftrap-function=abort")
279 }
280 }
281 }
282
Colin Cross635c3b02016-05-18 15:37:25 -0700283 blacklist := android.OptionalPathForModuleSrc(ctx, sanitize.Properties.Sanitize.Blacklist)
Colin Cross16b23492016-01-06 14:41:07 -0800284 if blacklist.Valid() {
285 flags.CFlags = append(flags.CFlags, "-fsanitize-blacklist="+blacklist.String())
286 flags.CFlagsDeps = append(flags.CFlagsDeps, blacklist.Path())
287 }
288
289 return flags
290}
291
Colin Cross30d5f512016-05-03 18:02:42 -0700292func (sanitize *sanitize) inData() bool {
293 return sanitize.Properties.InData
294}
295
Colin Cross16b23492016-01-06 14:41:07 -0800296func (sanitize *sanitize) Sanitizer(t sanitizerType) bool {
297 if sanitize == nil {
298 return false
299 }
300
301 switch t {
302 case asan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700303 return Bool(sanitize.Properties.Sanitize.Address)
Colin Cross16b23492016-01-06 14:41:07 -0800304 case tsan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700305 return Bool(sanitize.Properties.Sanitize.Thread)
Colin Cross16b23492016-01-06 14:41:07 -0800306 default:
307 panic(fmt.Errorf("unknown sanitizerType %d", t))
308 }
309}
310
311func (sanitize *sanitize) SetSanitizer(t sanitizerType, b bool) {
312 switch t {
313 case asan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700314 sanitize.Properties.Sanitize.Address = boolPtr(b)
Colin Cross16b23492016-01-06 14:41:07 -0800315 case tsan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700316 sanitize.Properties.Sanitize.Thread = boolPtr(b)
Colin Cross16b23492016-01-06 14:41:07 -0800317 default:
318 panic(fmt.Errorf("unknown sanitizerType %d", t))
319 }
320 if b {
321 sanitize.Properties.SanitizerEnabled = true
322 }
323}
324
325// Propagate asan requirements down from binaries
Colin Cross635c3b02016-05-18 15:37:25 -0700326func sanitizerDepsMutator(t sanitizerType) func(android.TopDownMutatorContext) {
327 return func(mctx android.TopDownMutatorContext) {
Colin Cross16b23492016-01-06 14:41:07 -0800328 if c, ok := mctx.Module().(*Module); ok && c.sanitize.Sanitizer(t) {
329 mctx.VisitDepsDepthFirst(func(module blueprint.Module) {
330 if d, ok := mctx.Module().(*Module); ok && c.sanitize != nil &&
331 !c.sanitize.Properties.Sanitize.Never {
332 d.sanitize.Properties.SanitizeDep = true
333 }
334 })
335 }
336 }
337}
338
339// Create asan variants for modules that need them
Colin Cross635c3b02016-05-18 15:37:25 -0700340func sanitizerMutator(t sanitizerType) func(android.BottomUpMutatorContext) {
341 return func(mctx android.BottomUpMutatorContext) {
Colin Cross16b23492016-01-06 14:41:07 -0800342 if c, ok := mctx.Module().(*Module); ok && c.sanitize != nil {
343 if d, ok := c.linker.(baseLinkerInterface); ok && d.isDependencyRoot() && c.sanitize.Sanitizer(t) {
Colin Cross30d5f512016-05-03 18:02:42 -0700344 modules := mctx.CreateVariations(t.String())
345 modules[0].(*Module).sanitize.SetSanitizer(t, true)
Colin Crossb36ab1a2016-05-25 12:35:53 -0700346 if mctx.AConfig().EmbeddedInMake() && !c.Host() {
Colin Cross30d5f512016-05-03 18:02:42 -0700347 modules[0].(*Module).sanitize.Properties.InData = true
348 }
Colin Cross16b23492016-01-06 14:41:07 -0800349 } else if c.sanitize.Properties.SanitizeDep {
Colin Crossb36ab1a2016-05-25 12:35:53 -0700350 if c.Host() {
351 modules := mctx.CreateVariations(t.String())
352 modules[0].(*Module).sanitize.SetSanitizer(t, true)
353 modules[0].(*Module).sanitize.Properties.SanitizeDep = false
354 } else {
355 modules := mctx.CreateVariations("", t.String())
356 modules[0].(*Module).sanitize.SetSanitizer(t, false)
357 modules[1].(*Module).sanitize.SetSanitizer(t, true)
358 modules[0].(*Module).sanitize.Properties.SanitizeDep = false
359 modules[1].(*Module).sanitize.Properties.SanitizeDep = false
360 modules[1].(*Module).sanitize.Properties.InData = true
361 if mctx.AConfig().EmbeddedInMake() {
362 modules[0].(*Module).Properties.HideFromMake = true
363 }
Colin Cross30d5f512016-05-03 18:02:42 -0700364 }
Colin Cross16b23492016-01-06 14:41:07 -0800365 }
366 c.sanitize.Properties.SanitizeDep = false
367 }
368 }
369}