blob: df96b89c81ea7b40115d9e4127bee809497b0fed [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"
Jeff Gaston72765392017-11-28 16:37:53 -080019 "sort"
Colin Cross16b23492016-01-06 14:41:07 -080020 "strings"
Vishwath Mohane7128792017-11-17 11:08:10 -080021 "sync"
Colin Cross16b23492016-01-06 14:41:07 -080022
Colin Cross6b753602018-06-21 13:03:07 -070023 "github.com/google/blueprint"
Liz Kammerb2fc4702021-06-25 14:53:40 -040024 "github.com/google/blueprint/proptools"
Colin Cross6b753602018-06-21 13:03:07 -070025
Colin Cross635c3b02016-05-18 15:37:25 -070026 "android/soong/android"
Evgenii Stepanovaf36db12016-08-15 14:18:24 -070027 "android/soong/cc/config"
Kiyoung Kim48f37782021-07-07 12:42:39 +090028 "android/soong/snapshot"
Colin Cross16b23492016-01-06 14:41:07 -080029)
30
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -070031var (
32 // Any C flags added by sanitizer which libTooling tools may not
33 // understand also need to be added to ClangLibToolingUnknownCflags in
34 // cc/config/clang.go
Vishwath Mohanf3918d32017-02-14 07:59:33 -080035
Yi Kong20233a42019-08-21 01:38:40 -070036 asanCflags = []string{
37 "-fno-omit-frame-pointer",
Yi Kong20233a42019-08-21 01:38:40 -070038 }
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -070039 asanLdflags = []string{"-Wl,-u,__asan_preinit"}
Jayant Chowdhary9677e8c2017-06-15 14:45:18 -070040
Yi Kong286abc62021-11-04 16:14:14 +080041 hwasanCflags = []string{
42 "-fno-omit-frame-pointer",
43 "-Wno-frame-larger-than=",
Evgenii Stepanov96fa3dd2020-03-27 19:38:42 +000044 "-fsanitize-hwaddress-abi=platform",
Florian Mayer0b981f52022-02-16 23:46:53 +000045 "-mllvm", "-hwasan-use-after-scope=1",
Yi Kong286abc62021-11-04 16:14:14 +080046 }
47
48 // ThinLTO performs codegen during link time, thus these flags need to
49 // passed to both CFLAGS and LDFLAGS.
50 hwasanCommonflags = []string{
Evgenii Stepanov64bee4d2019-11-22 18:37:10 -080051 // The following improves debug location information
52 // availability at the cost of its accuracy. It increases
53 // the likelihood of a stack variable's frame offset
54 // to be recorded in the debug info, which is important
55 // for the quality of hwasan reports. The downside is a
56 // higher number of "optimized out" stack variables.
57 // b/112437883.
Yi Kong286abc62021-11-04 16:14:14 +080058 "-instcombine-lower-dbg-declare=0",
Mitch Phillipsb1c574f2020-06-22 13:28:23 -070059 // TODO(b/159343917): HWASan and GlobalISel don't play nicely, and
60 // GlobalISel is the default at -O0 on aarch64.
Yi Kong286abc62021-11-04 16:14:14 +080061 "--aarch64-enable-global-isel-at-O=-1",
62 "-fast-isel=false",
Evgenii Stepanov64bee4d2019-11-22 18:37:10 -080063 }
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -070064
Trevor Radcliffe391a25d2023-03-22 20:22:27 +000065 cfiBlocklistPath = "external/compiler-rt/lib/cfi"
66 cfiBlocklistFilename = "cfi_blocklist.txt"
Trevor Radcliffe9f4b4762023-04-04 20:13:42 +000067 cfiCrossDsoFlag = "-fsanitize-cfi-cross-dso"
68 cfiCflags = []string{"-flto", cfiCrossDsoFlag,
Trevor Radcliffe391a25d2023-03-22 20:22:27 +000069 "-fsanitize-ignorelist=" + cfiBlocklistPath + "/" + cfiBlocklistFilename}
Evgenii Stepanovdbf1d4f2018-08-31 12:54:33 -070070 // -flto and -fvisibility are required by clang when -fsanitize=cfi is
71 // used, but have no effect on assembly files
72 cfiAsflags = []string{"-flto", "-fvisibility=default"}
Trevor Radcliffe9f4b4762023-04-04 20:13:42 +000073 cfiLdflags = []string{"-flto", cfiCrossDsoFlag, "-fsanitize=cfi",
Pirama Arumuga Nainarbdb17f02017-08-28 21:50:17 -070074 "-Wl,-plugin-opt,O1"}
Trevor Radcliffe391a25d2023-03-22 20:22:27 +000075 cfiExportsMapPath = "build/soong/cc/config"
76 cfiExportsMapFilename = "cfi_exports.map"
77 cfiAssemblySupportFlag = "-fno-sanitize-cfi-canonical-jump-tables"
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -070078
Pirama Arumuga Nainar582fc2d2021-08-27 15:12:56 -070079 intOverflowCflags = []string{"-fsanitize-ignorelist=build/soong/cc/config/integer_overflow_blocklist.txt"}
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -080080
Peter Collingbournebd19db02019-03-06 10:38:48 -080081 minimalRuntimeFlags = []string{"-fsanitize-minimal-runtime", "-fno-sanitize-trap=integer,undefined",
Ivan Lozanoae6ae1d2018-10-08 09:29:39 -070082 "-fno-sanitize-recover=integer,undefined"}
Evgenii Stepanov2c6484e2019-05-15 12:49:54 -070083 hwasanGlobalOptions = []string{"heap_history_size=1023", "stack_history_size=512",
Christopher Ferris2fc8e032023-01-26 14:19:27 -080084 "export_memory_stats=0", "max_malloc_fill_size=131072", "malloc_fill_byte=0"}
Florian Mayer1866bbe2023-03-11 01:07:40 +000085 memtagStackCommonFlags = []string{"-march=armv8-a+memtag", "-mllvm", "-dom-tree-reachability-max-bbs-to-explore=128"}
Trevor Radcliffe4f95ee92023-01-19 16:02:47 +000086
87 hostOnlySanitizeFlags = []string{"-fno-sanitize-recover=all"}
88 deviceOnlySanitizeFlags = []string{"-fsanitize-trap=all", "-ftrap-function=abort"}
Dan Willemsencbceaab2016-10-13 16:44:07 -070089)
90
Ivan Lozano3968d8f2020-12-14 11:27:52 -050091type SanitizerType int
Colin Cross16b23492016-01-06 14:41:07 -080092
Colin Cross16b23492016-01-06 14:41:07 -080093const (
Ivan Lozano3968d8f2020-12-14 11:27:52 -050094 Asan SanitizerType = iota + 1
Tri Vo6eafc362021-04-01 11:29:09 -070095 Hwasan
Colin Cross16b23492016-01-06 14:41:07 -080096 tsan
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -070097 intOverflow
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -080098 scs
Ivan Lozano3968d8f2020-12-14 11:27:52 -050099 Fuzzer
Ivan Lozano62cd0382021-11-01 10:27:54 -0400100 Memtag_heap
Florian Mayerd8434a42022-08-31 20:57:03 +0000101 Memtag_stack
Liz Kammer75db9312021-07-07 16:41:50 -0400102 cfi // cfi is last to prevent it running before incompatible mutators
Colin Cross16b23492016-01-06 14:41:07 -0800103)
104
Liz Kammer75db9312021-07-07 16:41:50 -0400105var Sanitizers = []SanitizerType{
106 Asan,
107 Hwasan,
108 tsan,
109 intOverflow,
110 scs,
111 Fuzzer,
Ivan Lozano62cd0382021-11-01 10:27:54 -0400112 Memtag_heap,
Florian Mayerd8434a42022-08-31 20:57:03 +0000113 Memtag_stack,
Liz Kammer75db9312021-07-07 16:41:50 -0400114 cfi, // cfi is last to prevent it running before incompatible mutators
115}
116
Jiyong Park82226632019-02-01 10:50:50 +0900117// Name of the sanitizer variation for this sanitizer type
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500118func (t SanitizerType) variationName() string {
Colin Cross16b23492016-01-06 14:41:07 -0800119 switch t {
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500120 case Asan:
Colin Cross16b23492016-01-06 14:41:07 -0800121 return "asan"
Tri Vo6eafc362021-04-01 11:29:09 -0700122 case Hwasan:
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700123 return "hwasan"
Colin Cross16b23492016-01-06 14:41:07 -0800124 case tsan:
125 return "tsan"
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700126 case intOverflow:
127 return "intOverflow"
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000128 case cfi:
129 return "cfi"
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -0800130 case scs:
131 return "scs"
Ivan Lozano62cd0382021-11-01 10:27:54 -0400132 case Memtag_heap:
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700133 return "memtag_heap"
Florian Mayerd8434a42022-08-31 20:57:03 +0000134 case Memtag_stack:
135 return "memtag_stack"
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500136 case Fuzzer:
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -0700137 return "fuzzer"
Colin Cross16b23492016-01-06 14:41:07 -0800138 default:
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500139 panic(fmt.Errorf("unknown SanitizerType %d", t))
Colin Cross16b23492016-01-06 14:41:07 -0800140 }
141}
142
Jiyong Park82226632019-02-01 10:50:50 +0900143// This is the sanitizer names in SANITIZE_[TARGET|HOST]
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500144func (t SanitizerType) name() string {
Jiyong Park82226632019-02-01 10:50:50 +0900145 switch t {
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500146 case Asan:
Jiyong Park82226632019-02-01 10:50:50 +0900147 return "address"
Tri Vo6eafc362021-04-01 11:29:09 -0700148 case Hwasan:
Jiyong Park82226632019-02-01 10:50:50 +0900149 return "hwaddress"
Ivan Lozano62cd0382021-11-01 10:27:54 -0400150 case Memtag_heap:
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700151 return "memtag_heap"
Florian Mayerd8434a42022-08-31 20:57:03 +0000152 case Memtag_stack:
153 return "memtag_stack"
Jiyong Park82226632019-02-01 10:50:50 +0900154 case tsan:
155 return "thread"
156 case intOverflow:
157 return "integer_overflow"
158 case cfi:
159 return "cfi"
160 case scs:
161 return "shadow-call-stack"
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500162 case Fuzzer:
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -0700163 return "fuzzer"
Jiyong Park82226632019-02-01 10:50:50 +0900164 default:
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500165 panic(fmt.Errorf("unknown SanitizerType %d", t))
Jiyong Park82226632019-02-01 10:50:50 +0900166 }
167}
168
Liz Kammer75db9312021-07-07 16:41:50 -0400169func (t SanitizerType) registerMutators(ctx android.RegisterMutatorsContext) {
170 switch t {
Lukacs T. Berki6c716762022-06-13 20:50:39 +0200171 case cfi, Hwasan, Asan, tsan, Fuzzer, scs:
172 sanitizer := &sanitizerSplitMutator{t}
173 ctx.TopDown(t.variationName()+"_markapexes", sanitizer.markSanitizableApexesMutator)
174 ctx.Transition(t.variationName(), sanitizer)
Florian Mayerd8434a42022-08-31 20:57:03 +0000175 case Memtag_heap, Memtag_stack, intOverflow:
Liz Kammer75db9312021-07-07 16:41:50 -0400176 // do nothing
177 default:
178 panic(fmt.Errorf("unknown SanitizerType %d", t))
179 }
180}
181
Liz Kammerfd8a49f2022-10-31 10:31:11 -0400182// shouldPropagateToSharedLibraryDeps returns whether a sanitizer type should propagate to share
183// dependencies. In most cases, sanitizers only propagate to static dependencies; however, some
184// sanitizers also must be enabled for shared libraries for linking.
185func (t SanitizerType) shouldPropagateToSharedLibraryDeps() bool {
186 switch t {
187 case Fuzzer:
188 // Typically, shared libs are not split. However, for fuzzer, we split even for shared libs
189 // because a library sanitized for fuzzer can't be linked from a library that isn't sanitized
190 // for fuzzer.
191 return true
192 default:
193 return false
194 }
195}
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500196func (*Module) SanitizerSupported(t SanitizerType) bool {
197 switch t {
198 case Asan:
199 return true
Tri Vo6eafc362021-04-01 11:29:09 -0700200 case Hwasan:
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500201 return true
202 case tsan:
203 return true
204 case intOverflow:
205 return true
206 case cfi:
207 return true
208 case scs:
209 return true
210 case Fuzzer:
211 return true
Ivan Lozano62cd0382021-11-01 10:27:54 -0400212 case Memtag_heap:
213 return true
Florian Mayerd8434a42022-08-31 20:57:03 +0000214 case Memtag_stack:
215 return true
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500216 default:
217 return false
218 }
219}
220
221// incompatibleWithCfi returns true if a sanitizer is incompatible with CFI.
222func (t SanitizerType) incompatibleWithCfi() bool {
Tri Vo6eafc362021-04-01 11:29:09 -0700223 return t == Asan || t == Fuzzer || t == Hwasan
Jiyong Park1d1119f2019-07-29 21:27:18 +0900224}
225
Martin Stjernholmb0249572020-09-15 02:32:35 +0100226type SanitizeUserProps struct {
Liz Kammer75b9b402021-06-25 15:19:27 -0400227 // Prevent use of any sanitizers on this module
Martin Stjernholmb0249572020-09-15 02:32:35 +0100228 Never *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -0800229
Liz Kammer75b9b402021-06-25 15:19:27 -0400230 // ASan (Address sanitizer), incompatible with static binaries.
231 // Always runs in a diagnostic mode.
232 // Use of address sanitizer disables cfi sanitizer.
233 // Hwaddress sanitizer takes precedence over this sanitizer.
234 Address *bool `android:"arch_variant"`
235 // TSan (Thread sanitizer), incompatible with static binaries and 32 bit architectures.
236 // Always runs in a diagnostic mode.
237 // Use of thread sanitizer disables cfi and scudo sanitizers.
238 // Hwaddress sanitizer takes precedence over this sanitizer.
239 Thread *bool `android:"arch_variant"`
240 // HWASan (Hardware Address sanitizer).
241 // Use of hwasan sanitizer disables cfi, address, thread, and scudo sanitizers.
Martin Stjernholmb0249572020-09-15 02:32:35 +0100242 Hwaddress *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -0800243
Liz Kammer75b9b402021-06-25 15:19:27 -0400244 // Undefined behavior sanitizer
245 All_undefined *bool `android:"arch_variant"`
246 // Subset of undefined behavior sanitizer
247 Undefined *bool `android:"arch_variant"`
248 // List of specific undefined behavior sanitizers to enable
249 Misc_undefined []string `android:"arch_variant"`
250 // Fuzzer, incompatible with static binaries.
251 Fuzzer *bool `android:"arch_variant"`
252 // safe-stack sanitizer, incompatible with 32-bit architectures.
253 Safestack *bool `android:"arch_variant"`
254 // cfi sanitizer, incompatible with asan, hwasan, fuzzer, or Darwin
255 Cfi *bool `android:"arch_variant"`
256 // signed/unsigned integer overflow sanitizer, incompatible with Darwin.
257 Integer_overflow *bool `android:"arch_variant"`
258 // scudo sanitizer, incompatible with asan, hwasan, tsan
259 // This should not be used in Android 11+ : https://source.android.com/devices/tech/debug/scudo
260 // deprecated
261 Scudo *bool `android:"arch_variant"`
Elliott Hughese4793bc2023-02-09 21:15:47 +0000262 // shadow-call-stack sanitizer, only available on arm64/riscv64.
Liz Kammer75b9b402021-06-25 15:19:27 -0400263 Scs *bool `android:"arch_variant"`
264 // Memory-tagging, only available on arm64
265 // if diag.memtag unset or false, enables async memory tagging
Florian Mayer00ab5cf2022-08-31 18:30:18 +0000266 Memtag_heap *bool `android:"arch_variant"`
Florian Mayerd8434a42022-08-31 20:57:03 +0000267 // Memory-tagging stack instrumentation, only available on arm64
268 // Adds instrumentation to detect stack buffer overflows and use-after-scope using MTE.
269 Memtag_stack *bool `android:"arch_variant"`
Martin Stjernholmb0249572020-09-15 02:32:35 +0100270
271 // A modifier for ASAN and HWASAN for write only instrumentation
272 Writeonly *bool `android:"arch_variant"`
273
274 // Sanitizers to run in the diagnostic mode (as opposed to the release mode).
275 // Replaces abort() on error with a human-readable error message.
276 // Address and Thread sanitizers always run in diagnostic mode.
277 Diag struct {
Liz Kammer75b9b402021-06-25 15:19:27 -0400278 // Undefined behavior sanitizer, diagnostic mode
279 Undefined *bool `android:"arch_variant"`
280 // cfi sanitizer, diagnostic mode, incompatible with asan, hwasan, fuzzer, or Darwin
281 Cfi *bool `android:"arch_variant"`
282 // signed/unsigned integer overflow sanitizer, diagnostic mode, incompatible with Darwin.
283 Integer_overflow *bool `android:"arch_variant"`
284 // Memory-tagging, only available on arm64
285 // requires sanitizer.memtag: true
286 // if set, enables sync memory tagging
287 Memtag_heap *bool `android:"arch_variant"`
288 // List of specific undefined behavior sanitizers to enable in diagnostic mode
289 Misc_undefined []string `android:"arch_variant"`
290 // List of sanitizers to pass to -fno-sanitize-recover
291 // results in only the first detected error for these sanitizers being reported and program then
292 // exits with a non-zero exit code.
293 No_recover []string `android:"arch_variant"`
Cindy Zhoud3fe4922020-12-01 11:14:30 -0800294 } `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -0800295
Cindy Zhou8cd45de2020-11-16 08:41:00 -0800296 // Sanitizers to run with flag configuration specified
297 Config struct {
298 // Enables CFI support flags for assembly-heavy libraries
299 Cfi_assembly_support *bool `android:"arch_variant"`
Cindy Zhoud3fe4922020-12-01 11:14:30 -0800300 } `android:"arch_variant"`
Cindy Zhou8cd45de2020-11-16 08:41:00 -0800301
Liz Kammer75b9b402021-06-25 15:19:27 -0400302 // List of sanitizers to pass to -fsanitize-recover
303 // allows execution to continue for these sanitizers to detect multiple errors rather than only
304 // the first one
Martin Stjernholmb0249572020-09-15 02:32:35 +0100305 Recover []string
Jasraj Bedibb4511d2020-07-23 22:58:17 +0000306
Pirama Arumuga Nainar582fc2d2021-08-27 15:12:56 -0700307 // value to pass to -fsanitize-ignorelist
Martin Stjernholmb0249572020-09-15 02:32:35 +0100308 Blocklist *string
309}
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700310
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400311type sanitizeMutatedProperties struct {
312 // Whether sanitizers can be enabled on this module
313 Never *bool `blueprint:"mutated"`
314
315 // Whether ASan (Address sanitizer) is enabled for this module.
316 // Hwaddress sanitizer takes precedence over this sanitizer.
317 Address *bool `blueprint:"mutated"`
318 // Whether TSan (Thread sanitizer) is enabled for this module
319 Thread *bool `blueprint:"mutated"`
320 // Whether HWASan (Hardware Address sanitizer) is enabled for this module
321 Hwaddress *bool `blueprint:"mutated"`
322
323 // Whether Undefined behavior sanitizer is enabled for this module
324 All_undefined *bool `blueprint:"mutated"`
325 // Whether undefined behavior sanitizer subset is enabled for this module
326 Undefined *bool `blueprint:"mutated"`
327 // List of specific undefined behavior sanitizers enabled for this module
328 Misc_undefined []string `blueprint:"mutated"`
329 // Whether Fuzzeris enabled for this module
330 Fuzzer *bool `blueprint:"mutated"`
331 // whether safe-stack sanitizer is enabled for this module
332 Safestack *bool `blueprint:"mutated"`
333 // Whether cfi sanitizer is enabled for this module
334 Cfi *bool `blueprint:"mutated"`
335 // Whether signed/unsigned integer overflow sanitizer is enabled for this module
336 Integer_overflow *bool `blueprint:"mutated"`
337 // Whether scudo sanitizer is enabled for this module
338 Scudo *bool `blueprint:"mutated"`
339 // Whether shadow-call-stack sanitizer is enabled for this module.
340 Scs *bool `blueprint:"mutated"`
341 // Whether Memory-tagging is enabled for this module
342 Memtag_heap *bool `blueprint:"mutated"`
343 // Whether Memory-tagging stack instrumentation is enabled for this module
344 Memtag_stack *bool `blueprint:"mutated"`
345
346 // Whether a modifier for ASAN and HWASAN for write only instrumentation is enabled for this
347 // module
348 Writeonly *bool `blueprint:"mutated"`
349
350 // Sanitizers to run in the diagnostic mode (as opposed to the release mode).
351 Diag struct {
352 // Whether Undefined behavior sanitizer, diagnostic mode is enabled for this module
353 Undefined *bool `blueprint:"mutated"`
354 // Whether cfi sanitizer, diagnostic mode is enabled for this module
355 Cfi *bool `blueprint:"mutated"`
356 // Whether signed/unsigned integer overflow sanitizer, diagnostic mode is enabled for this
357 // module
358 Integer_overflow *bool `blueprint:"mutated"`
359 // Whether Memory-tagging, diagnostic mode is enabled for this module
360 Memtag_heap *bool `blueprint:"mutated"`
361 // List of specific undefined behavior sanitizers enabled in diagnostic mode
362 Misc_undefined []string `blueprint:"mutated"`
363 } `blueprint:"mutated"`
364}
365
Martin Stjernholmb0249572020-09-15 02:32:35 +0100366type SanitizeProperties struct {
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400367 Sanitize SanitizeUserProps `android:"arch_variant"`
368 SanitizeMutated sanitizeMutatedProperties `blueprint:"mutated"`
369
370 SanitizerEnabled bool `blueprint:"mutated"`
371 MinimalRuntimeDep bool `blueprint:"mutated"`
372 BuiltinsDep bool `blueprint:"mutated"`
373 UbsanRuntimeDep bool `blueprint:"mutated"`
374 InSanitizerDir bool `blueprint:"mutated"`
375 Sanitizers []string `blueprint:"mutated"`
376 DiagSanitizers []string `blueprint:"mutated"`
Colin Cross16b23492016-01-06 14:41:07 -0800377}
378
379type sanitize struct {
380 Properties SanitizeProperties
381}
382
Cindy Zhou18417cb2020-12-10 07:12:38 -0800383// Mark this tag with a check to see if apex dependency check should be skipped
384func (t libraryDependencyTag) SkipApexAllowedDependenciesCheck() bool {
385 return t.skipApexAllowedDependenciesCheck
386}
387
388var _ android.SkipApexAllowedDependenciesCheck = (*libraryDependencyTag)(nil)
389
Trevor Radcliffe4f95ee92023-01-19 16:02:47 +0000390var exportedVars = android.NewExportedVariables(pctx)
391
Vishwath Mohane7128792017-11-17 11:08:10 -0800392func init() {
Trevor Radcliffe4f95ee92023-01-19 16:02:47 +0000393 exportedVars.ExportStringListStaticVariable("HostOnlySanitizeFlags", hostOnlySanitizeFlags)
394 exportedVars.ExportStringList("DeviceOnlySanitizeFlags", deviceOnlySanitizeFlags)
395
Trevor Radcliffe391a25d2023-03-22 20:22:27 +0000396 // Leave out "-flto" from the slices exported to bazel, as we will use the
Trevor Radcliffe9f4b4762023-04-04 20:13:42 +0000397 // dedicated LTO feature for this. For C Flags and Linker Flags, also leave
398 // out the cross DSO flag which will be added separately by transitions.
399 exportedVars.ExportStringList("CfiCFlags", cfiCflags[2:])
400 exportedVars.ExportStringList("CfiLdFlags", cfiLdflags[2:])
Trevor Radcliffe391a25d2023-03-22 20:22:27 +0000401 exportedVars.ExportStringList("CfiAsFlags", cfiAsflags[1:])
Trevor Radcliffe391a25d2023-03-22 20:22:27 +0000402
Trevor Radcliffe9f4b4762023-04-04 20:13:42 +0000403 exportedVars.ExportString("CfiCrossDsoFlag", cfiCrossDsoFlag)
Trevor Radcliffe391a25d2023-03-22 20:22:27 +0000404 exportedVars.ExportString("CfiBlocklistPath", cfiBlocklistPath)
405 exportedVars.ExportString("CfiBlocklistFilename", cfiBlocklistFilename)
406 exportedVars.ExportString("CfiExportsMapPath", cfiExportsMapPath)
407 exportedVars.ExportString("CfiExportsMapFilename", cfiExportsMapFilename)
408 exportedVars.ExportString("CfiAssemblySupportFlag", cfiAssemblySupportFlag)
409
Vishwath Mohane7128792017-11-17 11:08:10 -0800410 android.RegisterMakeVarsProvider(pctx, cfiMakeVarsProvider)
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700411 android.RegisterMakeVarsProvider(pctx, hwasanMakeVarsProvider)
Vishwath Mohane7128792017-11-17 11:08:10 -0800412}
413
Colin Cross16b23492016-01-06 14:41:07 -0800414func (sanitize *sanitize) props() []interface{} {
415 return []interface{}{&sanitize.Properties}
416}
417
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400418func (p *sanitizeMutatedProperties) copyUserPropertiesToMutated(userProps *SanitizeUserProps) {
419 p.Never = userProps.Never
420 p.Address = userProps.Address
421 p.All_undefined = userProps.All_undefined
422 p.Cfi = userProps.Cfi
423 p.Fuzzer = userProps.Fuzzer
424 p.Hwaddress = userProps.Hwaddress
425 p.Integer_overflow = userProps.Integer_overflow
426 p.Memtag_heap = userProps.Memtag_heap
427 p.Memtag_stack = userProps.Memtag_stack
428 p.Safestack = userProps.Safestack
429 p.Scs = userProps.Scs
430 p.Scudo = userProps.Scudo
431 p.Thread = userProps.Thread
432 p.Undefined = userProps.Undefined
433 p.Writeonly = userProps.Writeonly
434
435 p.Misc_undefined = make([]string, 0, len(userProps.Misc_undefined))
436 for _, v := range userProps.Misc_undefined {
437 p.Misc_undefined = append(p.Misc_undefined, v)
438 }
439
440 p.Diag.Cfi = userProps.Diag.Cfi
441 p.Diag.Integer_overflow = userProps.Diag.Integer_overflow
442 p.Diag.Memtag_heap = userProps.Diag.Memtag_heap
443 p.Diag.Undefined = userProps.Diag.Undefined
444
445 p.Diag.Misc_undefined = make([]string, 0, len(userProps.Diag.Misc_undefined))
446 for _, v := range userProps.Diag.Misc_undefined {
447 p.Diag.Misc_undefined = append(p.Diag.Misc_undefined, v)
448 }
449}
450
Colin Cross16b23492016-01-06 14:41:07 -0800451func (sanitize *sanitize) begin(ctx BaseModuleContext) {
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400452 s := &sanitize.Properties.SanitizeMutated
453 s.copyUserPropertiesToMutated(&sanitize.Properties.Sanitize)
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700454
Colin Cross16b23492016-01-06 14:41:07 -0800455 // Don't apply sanitizers to NDK code.
Jeff Gastonaf3cc2d2017-09-27 17:01:44 -0700456 if ctx.useSdk() {
Nan Zhang0007d812017-11-07 10:57:05 -0800457 s.Never = BoolPtr(true)
Colin Cross16b23492016-01-06 14:41:07 -0800458 }
459
460 // Never always wins.
Nan Zhang0007d812017-11-07 10:57:05 -0800461 if Bool(s.Never) {
Colin Cross16b23492016-01-06 14:41:07 -0800462 return
463 }
464
Florian Mayerd8434a42022-08-31 20:57:03 +0000465 // cc_test targets default to SYNC MemTag unless explicitly set to ASYNC (via diag: {memtag_heap: false}).
Liz Kammer7b920b42021-06-22 16:57:27 -0400466 if ctx.testBinary() {
467 if s.Memtag_heap == nil {
468 s.Memtag_heap = proptools.BoolPtr(true)
469 }
470 if s.Diag.Memtag_heap == nil {
471 s.Diag.Memtag_heap = proptools.BoolPtr(true)
472 }
Evgenii Stepanov04896ca2021-01-12 18:28:33 -0800473 }
474
Colin Cross16b23492016-01-06 14:41:07 -0800475 var globalSanitizers []string
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700476 var globalSanitizersDiag []string
477
Dan Willemsen8536d6b2018-10-07 20:54:34 -0700478 if ctx.Host() {
479 if !ctx.Windows() {
480 globalSanitizers = ctx.Config().SanitizeHost()
481 }
482 } else {
483 arches := ctx.Config().SanitizeDeviceArch()
484 if len(arches) == 0 || inList(ctx.Arch().ArchType.Name, arches) {
485 globalSanitizers = ctx.Config().SanitizeDevice()
486 globalSanitizersDiag = ctx.Config().SanitizeDeviceDiag()
Colin Cross16b23492016-01-06 14:41:07 -0800487 }
488 }
489
Colin Cross16b23492016-01-06 14:41:07 -0800490 if len(globalSanitizers) > 0 {
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000491 var found bool
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700492 if found, globalSanitizers = removeFromList("undefined", globalSanitizers); found && s.All_undefined == nil {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400493 s.All_undefined = proptools.BoolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000494 }
Colin Cross16b23492016-01-06 14:41:07 -0800495
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700496 if found, globalSanitizers = removeFromList("default-ub", globalSanitizers); found && s.Undefined == nil {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400497 s.Undefined = proptools.BoolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000498 }
499
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -0700500 if found, globalSanitizers = removeFromList("address", globalSanitizers); found && s.Address == nil {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400501 s.Address = proptools.BoolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000502 }
503
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700504 if found, globalSanitizers = removeFromList("thread", globalSanitizers); found && s.Thread == nil {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400505 s.Thread = proptools.BoolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000506 }
507
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -0700508 if found, globalSanitizers = removeFromList("fuzzer", globalSanitizers); found && s.Fuzzer == nil {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400509 s.Fuzzer = proptools.BoolPtr(true)
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700510 }
511
512 if found, globalSanitizers = removeFromList("safe-stack", globalSanitizers); found && s.Safestack == nil {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400513 s.Safestack = proptools.BoolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000514 }
515
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700516 if found, globalSanitizers = removeFromList("cfi", globalSanitizers); found && s.Cfi == nil {
Colin Cross6510f912017-11-29 00:27:14 -0800517 if !ctx.Config().CFIDisabledForPath(ctx.ModuleDir()) {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400518 s.Cfi = proptools.BoolPtr(true)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700519 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700520 }
521
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700522 // Global integer_overflow builds do not support static libraries.
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700523 if found, globalSanitizers = removeFromList("integer_overflow", globalSanitizers); found && s.Integer_overflow == nil {
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700524 if !ctx.Config().IntegerOverflowDisabledForPath(ctx.ModuleDir()) && !ctx.static() {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400525 s.Integer_overflow = proptools.BoolPtr(true)
Ivan Lozano5f595532017-07-13 14:46:05 -0700526 }
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700527 }
528
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700529 if found, globalSanitizers = removeFromList("scudo", globalSanitizers); found && s.Scudo == nil {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400530 s.Scudo = proptools.BoolPtr(true)
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700531 }
532
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700533 if found, globalSanitizers = removeFromList("hwaddress", globalSanitizers); found && s.Hwaddress == nil {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400534 s.Hwaddress = proptools.BoolPtr(true)
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700535 }
536
Jasraj Bedibb4511d2020-07-23 22:58:17 +0000537 if found, globalSanitizers = removeFromList("writeonly", globalSanitizers); found && s.Writeonly == nil {
538 // Hwaddress and Address are set before, so we can check them here
539 // If they aren't explicitly set in the blueprint/SANITIZE_(HOST|TARGET), they would be nil instead of false
540 if s.Address == nil && s.Hwaddress == nil {
541 ctx.ModuleErrorf("writeonly modifier cannot be used without 'address' or 'hwaddress'")
542 }
Liz Kammerb2fc4702021-06-25 14:53:40 -0400543 s.Writeonly = proptools.BoolPtr(true)
Jasraj Bedibb4511d2020-07-23 22:58:17 +0000544 }
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700545 if found, globalSanitizers = removeFromList("memtag_heap", globalSanitizers); found && s.Memtag_heap == nil {
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -0800546 if !ctx.Config().MemtagHeapDisabledForPath(ctx.ModuleDir()) {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400547 s.Memtag_heap = proptools.BoolPtr(true)
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -0800548 }
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700549 }
Jasraj Bedibb4511d2020-07-23 22:58:17 +0000550
Florian Mayerd8434a42022-08-31 20:57:03 +0000551 if found, globalSanitizers = removeFromList("memtag_stack", globalSanitizers); found && s.Memtag_stack == nil {
552 s.Memtag_stack = proptools.BoolPtr(true)
553 }
554
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000555 if len(globalSanitizers) > 0 {
556 ctx.ModuleErrorf("unknown global sanitizer option %s", globalSanitizers[0])
557 }
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700558
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700559 // Global integer_overflow builds do not support static library diagnostics.
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700560 if found, globalSanitizersDiag = removeFromList("integer_overflow", globalSanitizersDiag); found &&
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700561 s.Diag.Integer_overflow == nil && Bool(s.Integer_overflow) && !ctx.static() {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400562 s.Diag.Integer_overflow = proptools.BoolPtr(true)
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700563 }
564
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700565 if found, globalSanitizersDiag = removeFromList("cfi", globalSanitizersDiag); found &&
566 s.Diag.Cfi == nil && Bool(s.Cfi) {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400567 s.Diag.Cfi = proptools.BoolPtr(true)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700568 }
569
Evgenii Stepanov04896ca2021-01-12 18:28:33 -0800570 if found, globalSanitizersDiag = removeFromList("memtag_heap", globalSanitizersDiag); found &&
571 s.Diag.Memtag_heap == nil && Bool(s.Memtag_heap) {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400572 s.Diag.Memtag_heap = proptools.BoolPtr(true)
Evgenii Stepanov04896ca2021-01-12 18:28:33 -0800573 }
574
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700575 if len(globalSanitizersDiag) > 0 {
576 ctx.ModuleErrorf("unknown global sanitizer diagnostics option %s", globalSanitizersDiag[0])
577 }
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700578 }
Colin Cross3c344ef2016-07-18 15:44:56 -0700579
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -0800580 // Enable Memtag for all components in the include paths (for Aarch64 only)
Colin Cross88a029f2022-06-23 14:51:20 -0700581 if ctx.Arch().ArchType == android.Arm64 && ctx.toolchain().Bionic() {
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -0800582 if ctx.Config().MemtagHeapSyncEnabledForPath(ctx.ModuleDir()) {
Evgenii Stepanov04896ca2021-01-12 18:28:33 -0800583 if s.Memtag_heap == nil {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400584 s.Memtag_heap = proptools.BoolPtr(true)
Evgenii Stepanov04896ca2021-01-12 18:28:33 -0800585 }
586 if s.Diag.Memtag_heap == nil {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400587 s.Diag.Memtag_heap = proptools.BoolPtr(true)
Evgenii Stepanov04896ca2021-01-12 18:28:33 -0800588 }
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -0800589 } else if ctx.Config().MemtagHeapAsyncEnabledForPath(ctx.ModuleDir()) {
Evgenii Stepanov04896ca2021-01-12 18:28:33 -0800590 if s.Memtag_heap == nil {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400591 s.Memtag_heap = proptools.BoolPtr(true)
Evgenii Stepanov04896ca2021-01-12 18:28:33 -0800592 }
Evgenii Stepanov4beaa0c2021-01-05 16:41:26 -0800593 }
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700594 }
595
Hang Lua98aab92023-03-17 13:17:22 +0800596 // Enable HWASan for all components in the include paths (for Aarch64 only)
597 if s.Hwaddress == nil && ctx.Config().HWASanEnabledForPath(ctx.ModuleDir()) &&
598 ctx.Arch().ArchType == android.Arm64 && ctx.toolchain().Bionic() {
599 s.Hwaddress = proptools.BoolPtr(true)
600 }
601
Elvis Chien9c993542021-06-25 01:15:17 +0800602 // Enable CFI for non-host components in the include paths
603 if s.Cfi == nil && ctx.Config().CFIEnabledForPath(ctx.ModuleDir()) && !ctx.Host() {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400604 s.Cfi = proptools.BoolPtr(true)
Vishwath Mohan3af8ee02018-03-30 02:55:23 +0000605 if inList("cfi", ctx.Config().SanitizeDeviceDiag()) {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400606 s.Diag.Cfi = proptools.BoolPtr(true)
Vishwath Mohan1fa3ac52017-10-31 02:26:14 -0700607 }
608 }
609
Elliott Hughesda3a0712020-03-06 16:55:28 -0800610 // Is CFI actually enabled?
611 if !ctx.Config().EnableCFI() {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400612 s.Cfi = nil
613 s.Diag.Cfi = nil
Vishwath Mohan1b017a72017-01-19 13:54:55 -0800614 }
615
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700616 // HWASan requires AArch64 hardware feature (top-byte-ignore).
Colin Cross88a029f2022-06-23 14:51:20 -0700617 if ctx.Arch().ArchType != android.Arm64 || !ctx.toolchain().Bionic() {
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700618 s.Hwaddress = nil
619 }
620
Elliott Hughese4793bc2023-02-09 21:15:47 +0000621 // SCS is only implemented on AArch64/riscv64.
622 if (ctx.Arch().ArchType != android.Arm64 && ctx.Arch().ArchType != android.Riscv64) || !ctx.toolchain().Bionic() {
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -0800623 s.Scs = nil
624 }
Elliott Hughes5beb42f2023-04-12 13:08:58 -0700625 // ...but temporarily globally disabled on riscv64 (http://b/277909695).
626 if ctx.Arch().ArchType == android.Riscv64 {
627 s.Scs = nil
628 }
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -0800629
Ivan Lozano62cd0382021-11-01 10:27:54 -0400630 // Memtag_heap is only implemented on AArch64.
Florian Mayerd8434a42022-08-31 20:57:03 +0000631 // Memtag ABI is Android specific for now, so disable for host.
632 if ctx.Arch().ArchType != android.Arm64 || !ctx.toolchain().Bionic() || ctx.Host() {
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700633 s.Memtag_heap = nil
Florian Mayerd8434a42022-08-31 20:57:03 +0000634 s.Memtag_stack = nil
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -0700635 }
636
Vishwath Mohan8f4fdd82017-04-20 07:42:52 -0700637 // Also disable CFI if ASAN is enabled.
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700638 if Bool(s.Address) || Bool(s.Hwaddress) {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400639 s.Cfi = nil
640 s.Diag.Cfi = nil
Florian Mayerd8434a42022-08-31 20:57:03 +0000641 // HWASAN and ASAN win against MTE.
642 s.Memtag_heap = nil
643 s.Memtag_stack = nil
Vishwath Mohan8f4fdd82017-04-20 07:42:52 -0700644 }
645
Colin Crossed12a042022-02-07 13:55:55 -0800646 // Disable sanitizers that depend on the UBSan runtime for windows/darwin builds.
647 if !ctx.Os().Linux() {
Liz Kammerb2fc4702021-06-25 14:53:40 -0400648 s.Cfi = nil
649 s.Diag.Cfi = nil
Ivan Lozanoa9255a82018-03-13 10:41:07 -0700650 s.Misc_undefined = nil
651 s.Undefined = nil
652 s.All_undefined = nil
653 s.Integer_overflow = nil
Vishwath Mohane7128792017-11-17 11:08:10 -0800654 }
655
Colin Crossed12a042022-02-07 13:55:55 -0800656 // Disable CFI for musl
657 if ctx.toolchain().Musl() {
658 s.Cfi = nil
659 s.Diag.Cfi = nil
660 }
661
Vishwath Mohan9ccbba02018-05-28 13:54:48 -0700662 // Also disable CFI for VNDK variants of components
663 if ctx.isVndk() && ctx.useVndk() {
Justin Yun08270c62022-12-19 17:01:26 +0900664 s.Cfi = nil
665 s.Diag.Cfi = nil
Inseob Kimeec88e12020-01-22 11:11:29 +0900666 }
667
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700668 // HWASan ramdisk (which is built from recovery) goes over some bootloader limit.
Yifan Hong60e0cfb2020-10-21 15:17:56 -0700669 // Keep libc instrumented so that ramdisk / vendor_ramdisk / recovery can run hwasan-instrumented code if necessary.
670 if (ctx.inRamdisk() || ctx.inVendorRamdisk() || ctx.inRecovery()) && !strings.HasPrefix(ctx.ModuleDir(), "bionic/libc") {
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700671 s.Hwaddress = nil
672 }
673
Colin Cross3c344ef2016-07-18 15:44:56 -0700674 if ctx.staticBinary() {
675 s.Address = nil
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -0700676 s.Fuzzer = nil
Colin Cross3c344ef2016-07-18 15:44:56 -0700677 s.Thread = nil
Colin Cross16b23492016-01-06 14:41:07 -0800678 }
679
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700680 if Bool(s.All_undefined) {
681 s.Undefined = nil
682 }
683
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700684 if !ctx.toolchain().Is64Bit() {
685 // TSAN and SafeStack are not supported on 32-bit architectures
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700686 s.Thread = nil
687 s.Safestack = nil
Colin Cross16b23492016-01-06 14:41:07 -0800688 // TODO(ccross): error for compile_multilib = "32"?
689 }
690
Evgenii Stepanov76cee232017-01-27 15:44:44 -0800691 if ctx.Os() != android.Windows && (Bool(s.All_undefined) || Bool(s.Undefined) || Bool(s.Address) || Bool(s.Thread) ||
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -0700692 Bool(s.Fuzzer) || Bool(s.Safestack) || Bool(s.Cfi) || Bool(s.Integer_overflow) || len(s.Misc_undefined) > 0 ||
Florian Mayerd8434a42022-08-31 20:57:03 +0000693 Bool(s.Scudo) || Bool(s.Hwaddress) || Bool(s.Scs) || Bool(s.Memtag_heap) || Bool(s.Memtag_stack)) {
Colin Cross3c344ef2016-07-18 15:44:56 -0700694 sanitize.Properties.SanitizerEnabled = true
695 }
696
Kostya Kortchinskyd5275c82019-02-01 08:42:56 -0800697 // Disable Scudo if ASan or TSan is enabled, or if it's disabled globally.
698 if Bool(s.Address) || Bool(s.Thread) || Bool(s.Hwaddress) || ctx.Config().DisableScudo() {
Kostya Kortchinskyd18ae5c2018-06-12 14:46:54 -0700699 s.Scudo = nil
700 }
701
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -0700702 if Bool(s.Hwaddress) {
703 s.Address = nil
704 s.Thread = nil
705 }
Mitch Phillips5007c4a2022-03-02 01:25:22 +0000706
707 // TODO(b/131771163): CFI transiently depends on LTO, and thus Fuzzer is
708 // mutually incompatible.
709 if Bool(s.Fuzzer) {
710 s.Cfi = nil
711 }
Colin Cross16b23492016-01-06 14:41:07 -0800712}
713
Chih-Hung Hsieh3567e622018-11-15 14:01:36 -0800714func toDisableImplicitIntegerChange(flags []string) bool {
715 // Returns true if any flag is fsanitize*integer, and there is
716 // no explicit flag about sanitize=implicit-integer-sign-change.
717 for _, f := range flags {
718 if strings.Contains(f, "sanitize=implicit-integer-sign-change") {
719 return false
720 }
721 }
722 for _, f := range flags {
723 if strings.HasPrefix(f, "-fsanitize") && strings.Contains(f, "integer") {
724 return true
725 }
726 }
727 return false
728}
729
Yabin Cuidb7dda82020-11-30 15:47:45 -0800730func toDisableUnsignedShiftBaseChange(flags []string) bool {
731 // Returns true if any flag is fsanitize*integer, and there is
732 // no explicit flag about sanitize=unsigned-shift-base.
733 for _, f := range flags {
734 if strings.Contains(f, "sanitize=unsigned-shift-base") {
735 return false
736 }
737 }
738 for _, f := range flags {
739 if strings.HasPrefix(f, "-fsanitize") && strings.Contains(f, "integer") {
740 return true
741 }
742 }
743 return false
744}
745
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400746func (s *sanitize) flags(ctx ModuleContext, flags Flags) Flags {
747 if !s.Properties.SanitizerEnabled && !s.Properties.UbsanRuntimeDep {
Colin Cross16b23492016-01-06 14:41:07 -0800748 return flags
749 }
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400750 sanProps := &s.Properties.SanitizeMutated
Colin Cross16b23492016-01-06 14:41:07 -0800751
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400752 if Bool(sanProps.Address) {
Colin Cross635c3b02016-05-18 15:37:25 -0700753 if ctx.Arch().ArchType == android.Arm {
Colin Cross16b23492016-01-06 14:41:07 -0800754 // Frame pointer based unwinder in ASan requires ARM frame setup.
755 // TODO: put in flags?
756 flags.RequiredInstructionSet = "arm"
757 }
Colin Cross4af21ed2019-11-04 09:37:55 -0800758 flags.Local.CFlags = append(flags.Local.CFlags, asanCflags...)
759 flags.Local.LdFlags = append(flags.Local.LdFlags, asanLdflags...)
Colin Cross16b23492016-01-06 14:41:07 -0800760
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400761 if Bool(sanProps.Writeonly) {
Jasraj Bedibb4511d2020-07-23 22:58:17 +0000762 flags.Local.CFlags = append(flags.Local.CFlags, "-mllvm", "-asan-instrument-reads=0")
763 }
764
Colin Cross16b23492016-01-06 14:41:07 -0800765 if ctx.Host() {
766 // -nodefaultlibs (provided with libc++) prevents the driver from linking
767 // libraries needed with -fsanitize=address. http://b/18650275 (WAI)
Colin Cross4af21ed2019-11-04 09:37:55 -0800768 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--no-as-needed")
Colin Cross16b23492016-01-06 14:41:07 -0800769 } else {
Colin Cross4af21ed2019-11-04 09:37:55 -0800770 flags.Local.CFlags = append(flags.Local.CFlags, "-mllvm", "-asan-globals=0")
Jiyong Parka2aca282019-02-02 13:13:38 +0900771 if ctx.bootstrap() {
772 flags.DynamicLinker = "/system/bin/bootstrap/linker_asan"
773 } else {
774 flags.DynamicLinker = "/system/bin/linker_asan"
775 }
Colin Cross16b23492016-01-06 14:41:07 -0800776 if flags.Toolchain.Is64Bit() {
777 flags.DynamicLinker += "64"
778 }
779 }
Colin Cross16b23492016-01-06 14:41:07 -0800780 }
781
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400782 if Bool(sanProps.Hwaddress) {
Colin Cross4af21ed2019-11-04 09:37:55 -0800783 flags.Local.CFlags = append(flags.Local.CFlags, hwasanCflags...)
Yi Kong286abc62021-11-04 16:14:14 +0800784
785 for _, flag := range hwasanCommonflags {
786 flags.Local.CFlags = append(flags.Local.CFlags, "-mllvm", flag)
787 }
788 for _, flag := range hwasanCommonflags {
789 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,-mllvm,"+flag)
790 }
791
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400792 if Bool(sanProps.Writeonly) {
Jasraj Bedibb4511d2020-07-23 22:58:17 +0000793 flags.Local.CFlags = append(flags.Local.CFlags, "-mllvm", "-hwasan-instrument-reads=0")
794 }
Florian Mayer95cd6db2023-03-23 17:48:07 -0700795 if !ctx.staticBinary() && !ctx.Host() {
796 if ctx.bootstrap() {
797 flags.DynamicLinker = "/system/bin/bootstrap/linker_hwasan64"
798 } else {
799 flags.DynamicLinker = "/system/bin/linker_hwasan64"
800 }
801 }
Yabin Cui6be405e2017-10-19 15:52:11 -0700802 }
803
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400804 if Bool(sanProps.Fuzzer) {
Colin Cross4af21ed2019-11-04 09:37:55 -0800805 flags.Local.CFlags = append(flags.Local.CFlags, "-fsanitize=fuzzer-no-link")
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -0700806
Mitch Phillips5007c4a2022-03-02 01:25:22 +0000807 // TODO(b/131771163): LTO and Fuzzer support is mutually incompatible.
808 _, flags.Local.LdFlags = removeFromList("-flto", flags.Local.LdFlags)
809 _, flags.Local.CFlags = removeFromList("-flto", flags.Local.CFlags)
810 flags.Local.LdFlags = append(flags.Local.LdFlags, "-fno-lto")
811 flags.Local.CFlags = append(flags.Local.CFlags, "-fno-lto")
812
Mitch Phillipsb8e593d2019-10-09 17:18:59 -0700813 // TODO(b/142430592): Upstream linker scripts for sanitizer runtime libraries
814 // discard the sancov_lowest_stack symbol, because it's emulated TLS (and thus
815 // doesn't match the linker script due to the "__emutls_v." prefix).
Colin Cross4af21ed2019-11-04 09:37:55 -0800816 flags.Local.LdFlags = append(flags.Local.LdFlags, "-fno-sanitize-coverage=stack-depth")
817 flags.Local.CFlags = append(flags.Local.CFlags, "-fno-sanitize-coverage=stack-depth")
Mitch Phillipsb8e593d2019-10-09 17:18:59 -0700818
Mitch Phillipsb9b3e792019-08-28 12:41:07 -0700819 // Disable fortify for fuzzing builds. Generally, we'll be building with
820 // UBSan or ASan here and the fortify checks pollute the stack traces.
Colin Cross4af21ed2019-11-04 09:37:55 -0800821 flags.Local.CFlags = append(flags.Local.CFlags, "-U_FORTIFY_SOURCE")
Mitch Phillips734b4cb2019-12-10 08:44:52 -0800822
823 // Build fuzzer-sanitized libraries with an $ORIGIN DT_RUNPATH. Android's
824 // linker uses DT_RUNPATH, not DT_RPATH. When we deploy cc_fuzz targets and
825 // their libraries to /data/fuzz/<arch>/lib, any transient shared library gets
826 // the DT_RUNPATH from the shared library above it, and not the executable,
827 // meaning that the lookup falls back to the system. Adding the $ORIGIN to the
828 // DT_RUNPATH here means that transient shared libraries can be found
829 // colocated with their parents.
830 flags.Local.LdFlags = append(flags.Local.LdFlags, `-Wl,-rpath,\$$ORIGIN`)
Colin Cross16b23492016-01-06 14:41:07 -0800831 }
832
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400833 if Bool(sanProps.Cfi) {
Evgenii Stepanov7ebf9fa2017-01-20 14:13:06 -0800834 if ctx.Arch().ArchType == android.Arm {
835 // __cfi_check needs to be built as Thumb (see the code in linker_cfi.cpp). LLVM is not set up
836 // to do this on a function basis, so force Thumb on the entire module.
837 flags.RequiredInstructionSet = "thumb"
838 }
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000839
Colin Cross4af21ed2019-11-04 09:37:55 -0800840 flags.Local.CFlags = append(flags.Local.CFlags, cfiCflags...)
841 flags.Local.AsFlags = append(flags.Local.AsFlags, cfiAsflags...)
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400842 if Bool(s.Properties.Sanitize.Config.Cfi_assembly_support) {
Trevor Radcliffe391a25d2023-03-22 20:22:27 +0000843 flags.Local.CFlags = append(flags.Local.CFlags, cfiAssemblySupportFlag)
Cindy Zhou8cd45de2020-11-16 08:41:00 -0800844 }
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000845 // Only append the default visibility flag if -fvisibility has not already been set
846 // to hidden.
Colin Cross4af21ed2019-11-04 09:37:55 -0800847 if !inList("-fvisibility=hidden", flags.Local.CFlags) {
848 flags.Local.CFlags = append(flags.Local.CFlags, "-fvisibility=default")
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000849 }
Colin Cross4af21ed2019-11-04 09:37:55 -0800850 flags.Local.LdFlags = append(flags.Local.LdFlags, cfiLdflags...)
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000851
852 if ctx.staticBinary() {
Colin Cross4af21ed2019-11-04 09:37:55 -0800853 _, flags.Local.CFlags = removeFromList("-fsanitize-cfi-cross-dso", flags.Local.CFlags)
854 _, flags.Local.LdFlags = removeFromList("-fsanitize-cfi-cross-dso", flags.Local.LdFlags)
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000855 }
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700856 }
857
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400858 if Bool(sanProps.Memtag_stack) {
Florian Mayerd8434a42022-08-31 20:57:03 +0000859 flags.Local.CFlags = append(flags.Local.CFlags, memtagStackCommonFlags...)
Florian Mayer25cd9812023-03-21 16:13:36 +0000860 // TODO(fmayer): remove -Wno-error once https://reviews.llvm.org/D127917 is in Android toolchain.
861 flags.Local.CFlags = append(flags.Local.CFlags, "-Wno-error=frame-larger-than")
Florian Mayerd8434a42022-08-31 20:57:03 +0000862 flags.Local.AsFlags = append(flags.Local.AsFlags, memtagStackCommonFlags...)
863 flags.Local.LdFlags = append(flags.Local.LdFlags, memtagStackCommonFlags...)
Florian Mayer25cd9812023-03-21 16:13:36 +0000864 // This works around LLD complaining about the stack frame size.
865 // TODO(fmayer): remove once https://reviews.llvm.org/D127917 is in Android toolchain.
866 flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--no-fatal-warnings")
Florian Mayerd8434a42022-08-31 20:57:03 +0000867 }
868
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400869 if (Bool(sanProps.Memtag_heap) || Bool(sanProps.Memtag_stack)) && ctx.binary() {
870 if Bool(sanProps.Diag.Memtag_heap) {
Florian Mayerd8434a42022-08-31 20:57:03 +0000871 flags.Local.LdFlags = append(flags.Local.LdFlags, "-fsanitize-memtag-mode=sync")
872 } else {
873 flags.Local.LdFlags = append(flags.Local.LdFlags, "-fsanitize-memtag-mode=async")
874 }
875 }
876
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400877 if Bool(sanProps.Integer_overflow) {
Colin Cross4af21ed2019-11-04 09:37:55 -0800878 flags.Local.CFlags = append(flags.Local.CFlags, intOverflowCflags...)
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -0700879 }
880
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400881 if len(s.Properties.Sanitizers) > 0 {
882 sanitizeArg := "-fsanitize=" + strings.Join(s.Properties.Sanitizers, ",")
Colin Cross4af21ed2019-11-04 09:37:55 -0800883 flags.Local.CFlags = append(flags.Local.CFlags, sanitizeArg)
884 flags.Local.AsFlags = append(flags.Local.AsFlags, sanitizeArg)
Colin Cross234b01d2022-02-07 13:49:03 -0800885 flags.Local.LdFlags = append(flags.Local.LdFlags, sanitizeArg)
886
Colin Crossed12a042022-02-07 13:55:55 -0800887 if ctx.toolchain().Bionic() || ctx.toolchain().Musl() {
888 // Bionic and musl sanitizer runtimes have already been added as dependencies so that
889 // the right variant of the runtime will be used (with the "-android" or "-musl"
890 // suffixes), so don't let clang the runtime library.
Colin Cross234b01d2022-02-07 13:49:03 -0800891 flags.Local.LdFlags = append(flags.Local.LdFlags, "-fno-sanitize-link-runtime")
892 } else {
Evgenii Stepanov76cee232017-01-27 15:44:44 -0800893 // Host sanitizers only link symbols in the final executable, so
894 // there will always be undefined symbols in intermediate libraries.
Colin Cross4af21ed2019-11-04 09:37:55 -0800895 _, flags.Global.LdFlags = removeFromList("-Wl,--no-undefined", flags.Global.LdFlags)
Colin Cross6c18d002022-06-02 15:11:50 -0700896 }
Ivan Lozano9ac32c72020-02-19 15:24:02 -0500897
Colin Cross6c18d002022-06-02 15:11:50 -0700898 if !ctx.toolchain().Bionic() {
899 // non-Bionic toolchain prebuilts are missing UBSan's vptr and function san.
900 // Musl toolchain prebuilts have vptr and function sanitizers, but enabling them
901 // implicitly enables RTTI which causes RTTI mismatch issues with dependencies.
902
Colin Cross234b01d2022-02-07 13:49:03 -0800903 flags.Local.CFlags = append(flags.Local.CFlags, "-fno-sanitize=vptr,function")
Ivan Lozano9ac32c72020-02-19 15:24:02 -0500904 }
905
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400906 if Bool(sanProps.Fuzzer) {
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -0700907 // When fuzzing, we wish to crash with diagnostics on any bug.
Colin Cross4af21ed2019-11-04 09:37:55 -0800908 flags.Local.CFlags = append(flags.Local.CFlags, "-fno-sanitize-trap=all", "-fno-sanitize-recover=all")
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -0700909 } else if ctx.Host() {
Trevor Radcliffe4f95ee92023-01-19 16:02:47 +0000910 flags.Local.CFlags = append(flags.Local.CFlags, hostOnlySanitizeFlags...)
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -0700911 } else {
Trevor Radcliffe4f95ee92023-01-19 16:02:47 +0000912 flags.Local.CFlags = append(flags.Local.CFlags, deviceOnlySanitizeFlags...)
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -0700913 }
Evgenii Stepanov59012812022-06-24 11:09:18 -0700914
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400915 if enableMinimalRuntime(s) {
Evgenii Stepanov59012812022-06-24 11:09:18 -0700916 flags.Local.CFlags = append(flags.Local.CFlags, strings.Join(minimalRuntimeFlags, " "))
917 }
918
Chih-Hung Hsieh3567e622018-11-15 14:01:36 -0800919 // http://b/119329758, Android core does not boot up with this sanitizer yet.
Colin Cross4af21ed2019-11-04 09:37:55 -0800920 if toDisableImplicitIntegerChange(flags.Local.CFlags) {
921 flags.Local.CFlags = append(flags.Local.CFlags, "-fno-sanitize=implicit-integer-sign-change")
Chih-Hung Hsieh3567e622018-11-15 14:01:36 -0800922 }
Yabin Cuidb7dda82020-11-30 15:47:45 -0800923 // http://b/171275751, Android doesn't build with this sanitizer yet.
924 if toDisableUnsignedShiftBaseChange(flags.Local.CFlags) {
925 flags.Local.CFlags = append(flags.Local.CFlags, "-fno-sanitize=unsigned-shift-base")
926 }
Colin Cross16b23492016-01-06 14:41:07 -0800927 }
928
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400929 if len(s.Properties.DiagSanitizers) > 0 {
930 flags.Local.CFlags = append(flags.Local.CFlags, "-fno-sanitize-trap="+strings.Join(s.Properties.DiagSanitizers, ","))
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700931 }
932 // FIXME: enable RTTI if diag + (cfi or vptr)
933
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400934 if s.Properties.Sanitize.Recover != nil {
Colin Cross4af21ed2019-11-04 09:37:55 -0800935 flags.Local.CFlags = append(flags.Local.CFlags, "-fsanitize-recover="+
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400936 strings.Join(s.Properties.Sanitize.Recover, ","))
Andreas Gampe97071162017-05-08 13:15:23 -0700937 }
938
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400939 if s.Properties.Sanitize.Diag.No_recover != nil {
Colin Cross4af21ed2019-11-04 09:37:55 -0800940 flags.Local.CFlags = append(flags.Local.CFlags, "-fno-sanitize-recover="+
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400941 strings.Join(s.Properties.Sanitize.Diag.No_recover, ","))
Ivan Lozano7929bba2018-12-12 09:36:31 -0800942 }
943
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400944 blocklist := android.OptionalPathForModuleSrc(ctx, s.Properties.Sanitize.Blocklist)
Pirama Arumuga Nainar6c4ccca2020-07-27 11:49:51 -0700945 if blocklist.Valid() {
Pirama Arumuga Nainar582fc2d2021-08-27 15:12:56 -0700946 flags.Local.CFlags = append(flags.Local.CFlags, "-fsanitize-ignorelist="+blocklist.String())
Pirama Arumuga Nainar6c4ccca2020-07-27 11:49:51 -0700947 flags.CFlagsDeps = append(flags.CFlagsDeps, blocklist.Path())
948 }
949
Colin Cross16b23492016-01-06 14:41:07 -0800950 return flags
951}
952
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400953func (s *sanitize) AndroidMkEntries(ctx AndroidMkContext, entries *android.AndroidMkEntries) {
Jiyong Park1d1119f2019-07-29 21:27:18 +0900954 // Add a suffix for cfi/hwasan/scs-enabled static/header libraries to allow surfacing
955 // both the sanitized and non-sanitized variants to make without a name conflict.
Colin Crossd80cbca2020-02-24 12:01:37 -0800956 if entries.Class == "STATIC_LIBRARIES" || entries.Class == "HEADER_LIBRARIES" {
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400957 if Bool(s.Properties.SanitizeMutated.Cfi) {
Colin Crossd80cbca2020-02-24 12:01:37 -0800958 entries.SubName += ".cfi"
Jiyong Park1d1119f2019-07-29 21:27:18 +0900959 }
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400960 if Bool(s.Properties.SanitizeMutated.Hwaddress) {
Colin Crossd80cbca2020-02-24 12:01:37 -0800961 entries.SubName += ".hwasan"
Jiyong Park1d1119f2019-07-29 21:27:18 +0900962 }
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400963 if Bool(s.Properties.SanitizeMutated.Scs) {
Colin Crossd80cbca2020-02-24 12:01:37 -0800964 entries.SubName += ".scs"
Jiyong Park1d1119f2019-07-29 21:27:18 +0900965 }
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -0800966 }
Colin Cross8ff9ef42017-05-08 13:44:11 -0700967}
968
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400969func (s *sanitize) inSanitizerDir() bool {
970 return s.Properties.InSanitizerDir
Colin Cross30d5f512016-05-03 18:02:42 -0700971}
972
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500973// getSanitizerBoolPtr returns the SanitizerTypes associated bool pointer from SanitizeProperties.
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400974func (s *sanitize) getSanitizerBoolPtr(t SanitizerType) *bool {
Vishwath Mohan95229302017-08-11 00:53:16 +0000975 switch t {
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500976 case Asan:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400977 return s.Properties.SanitizeMutated.Address
Tri Vo6eafc362021-04-01 11:29:09 -0700978 case Hwasan:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400979 return s.Properties.SanitizeMutated.Hwaddress
Vishwath Mohan95229302017-08-11 00:53:16 +0000980 case tsan:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400981 return s.Properties.SanitizeMutated.Thread
Vishwath Mohan95229302017-08-11 00:53:16 +0000982 case intOverflow:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400983 return s.Properties.SanitizeMutated.Integer_overflow
Vishwath Mohanb743e9c2017-11-01 09:20:21 +0000984 case cfi:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400985 return s.Properties.SanitizeMutated.Cfi
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -0800986 case scs:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400987 return s.Properties.SanitizeMutated.Scs
Ivan Lozano62cd0382021-11-01 10:27:54 -0400988 case Memtag_heap:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400989 return s.Properties.SanitizeMutated.Memtag_heap
Florian Mayerd8434a42022-08-31 20:57:03 +0000990 case Memtag_stack:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400991 return s.Properties.SanitizeMutated.Memtag_stack
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500992 case Fuzzer:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -0400993 return s.Properties.SanitizeMutated.Fuzzer
Vishwath Mohan95229302017-08-11 00:53:16 +0000994 default:
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500995 panic(fmt.Errorf("unknown SanitizerType %d", t))
Vishwath Mohan95229302017-08-11 00:53:16 +0000996 }
997}
998
Ivan Lozano3968d8f2020-12-14 11:27:52 -0500999// isUnsanitizedVariant returns true if no sanitizers are enabled.
Dan Albert7d1eecf2018-01-19 12:30:45 -08001000func (sanitize *sanitize) isUnsanitizedVariant() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001001 return !sanitize.isSanitizerEnabled(Asan) &&
Tri Vo6eafc362021-04-01 11:29:09 -07001002 !sanitize.isSanitizerEnabled(Hwasan) &&
Dan Albert7d1eecf2018-01-19 12:30:45 -08001003 !sanitize.isSanitizerEnabled(tsan) &&
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -08001004 !sanitize.isSanitizerEnabled(cfi) &&
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -07001005 !sanitize.isSanitizerEnabled(scs) &&
Ivan Lozano62cd0382021-11-01 10:27:54 -04001006 !sanitize.isSanitizerEnabled(Memtag_heap) &&
Florian Mayerd8434a42022-08-31 20:57:03 +00001007 !sanitize.isSanitizerEnabled(Memtag_stack) &&
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001008 !sanitize.isSanitizerEnabled(Fuzzer)
Dan Albert7d1eecf2018-01-19 12:30:45 -08001009}
1010
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001011// isVariantOnProductionDevice returns true if variant is for production devices (no non-production sanitizers enabled).
Jayant Chowdharyb7e08ca2018-05-10 15:29:24 -07001012func (sanitize *sanitize) isVariantOnProductionDevice() bool {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001013 return !sanitize.isSanitizerEnabled(Asan) &&
Tri Vo6eafc362021-04-01 11:29:09 -07001014 !sanitize.isSanitizerEnabled(Hwasan) &&
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -07001015 !sanitize.isSanitizerEnabled(tsan) &&
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001016 !sanitize.isSanitizerEnabled(Fuzzer)
Jayant Chowdharyb7e08ca2018-05-10 15:29:24 -07001017}
1018
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001019func (sanitize *sanitize) SetSanitizer(t SanitizerType, b bool) {
Liz Kammerb2fc4702021-06-25 14:53:40 -04001020 bPtr := proptools.BoolPtr(b)
1021 if !b {
1022 bPtr = nil
1023 }
Colin Cross16b23492016-01-06 14:41:07 -08001024 switch t {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001025 case Asan:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001026 sanitize.Properties.SanitizeMutated.Address = bPtr
Florian Mayer1bda2462022-09-29 15:48:08 -07001027 // For ASAN variant, we need to disable Memtag_stack
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001028 sanitize.Properties.SanitizeMutated.Memtag_stack = nil
Tri Vo6eafc362021-04-01 11:29:09 -07001029 case Hwasan:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001030 sanitize.Properties.SanitizeMutated.Hwaddress = bPtr
Florian Mayer1bda2462022-09-29 15:48:08 -07001031 // For HWAsan variant, we need to disable Memtag_stack
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001032 sanitize.Properties.SanitizeMutated.Memtag_stack = nil
Colin Cross16b23492016-01-06 14:41:07 -08001033 case tsan:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001034 sanitize.Properties.SanitizeMutated.Thread = bPtr
Ivan Lozano0c3a1ef2017-06-28 09:10:48 -07001035 case intOverflow:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001036 sanitize.Properties.SanitizeMutated.Integer_overflow = bPtr
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001037 case cfi:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001038 sanitize.Properties.SanitizeMutated.Cfi = bPtr
Peter Collingbourne8c7e6e22018-11-19 16:03:58 -08001039 case scs:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001040 sanitize.Properties.SanitizeMutated.Scs = bPtr
Ivan Lozano62cd0382021-11-01 10:27:54 -04001041 case Memtag_heap:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001042 sanitize.Properties.SanitizeMutated.Memtag_heap = bPtr
Florian Mayerd8434a42022-08-31 20:57:03 +00001043 case Memtag_stack:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001044 sanitize.Properties.SanitizeMutated.Memtag_stack = bPtr
Florian Mayer1bda2462022-09-29 15:48:08 -07001045 // We do not need to disable ASAN or HWASan here, as there is no Memtag_stack variant.
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001046 case Fuzzer:
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001047 sanitize.Properties.SanitizeMutated.Fuzzer = bPtr
Colin Cross16b23492016-01-06 14:41:07 -08001048 default:
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001049 panic(fmt.Errorf("unknown SanitizerType %d", t))
Colin Cross16b23492016-01-06 14:41:07 -08001050 }
1051 if b {
1052 sanitize.Properties.SanitizerEnabled = true
1053 }
1054}
1055
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001056// Check if the sanitizer is explicitly disabled (as opposed to nil by
1057// virtue of not being set).
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001058func (sanitize *sanitize) isSanitizerExplicitlyDisabled(t SanitizerType) bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001059 if sanitize == nil {
1060 return false
1061 }
1062
1063 sanitizerVal := sanitize.getSanitizerBoolPtr(t)
1064 return sanitizerVal != nil && *sanitizerVal == false
1065}
1066
1067// There isn't an analog of the method above (ie:isSanitizerExplicitlyEnabled)
1068// because enabling a sanitizer either directly (via the blueprint) or
1069// indirectly (via a mutator) sets the bool ptr to true, and you can't
1070// distinguish between the cases. It isn't needed though - both cases can be
1071// treated identically.
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001072func (sanitize *sanitize) isSanitizerEnabled(t SanitizerType) bool {
Vishwath Mohanb743e9c2017-11-01 09:20:21 +00001073 if sanitize == nil {
1074 return false
1075 }
1076
1077 sanitizerVal := sanitize.getSanitizerBoolPtr(t)
1078 return sanitizerVal != nil && *sanitizerVal == true
1079}
1080
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001081// IsSanitizableDependencyTag returns true if the dependency tag is sanitizable.
1082func IsSanitizableDependencyTag(tag blueprint.DependencyTag) bool {
Colin Cross6e511a92020-07-27 21:26:48 -07001083 switch t := tag.(type) {
1084 case dependencyTag:
1085 return t == reuseObjTag || t == objDepTag
1086 case libraryDependencyTag:
1087 return true
1088 default:
1089 return false
1090 }
Colin Cross6b753602018-06-21 13:03:07 -07001091}
1092
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001093func (m *Module) SanitizableDepTagChecker() SantizableDependencyTagChecker {
1094 return IsSanitizableDependencyTag
1095}
1096
Inseob Kimc42f2f22020-07-29 20:32:10 +09001097// Determines if the current module is a static library going to be captured
1098// as vendor snapshot. Such modules must create both cfi and non-cfi variants,
1099// except for ones which explicitly disable cfi.
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001100func needsCfiForVendorSnapshot(mctx android.BaseModuleContext) bool {
Justin Yun8814fc52022-12-15 21:45:35 +09001101 if inList("hwaddress", mctx.Config().SanitizeDevice()) {
1102 // cfi will not be built if SANITIZE_TARGET=hwaddress is set
1103 return false
1104 }
1105
Kiyoung Kim48f37782021-07-07 12:42:39 +09001106 if snapshot.IsVendorProprietaryModule(mctx) {
Inseob Kimc42f2f22020-07-29 20:32:10 +09001107 return false
1108 }
1109
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001110 c := mctx.Module().(PlatformSanitizeable)
Inseob Kimc42f2f22020-07-29 20:32:10 +09001111
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001112 if !c.InVendor() {
Inseob Kimc42f2f22020-07-29 20:32:10 +09001113 return false
1114 }
1115
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001116 if !c.StaticallyLinked() {
Inseob Kimc42f2f22020-07-29 20:32:10 +09001117 return false
1118 }
1119
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001120 if c.IsPrebuilt() {
Inseob Kimc42f2f22020-07-29 20:32:10 +09001121 return false
1122 }
1123
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001124 if !c.SanitizerSupported(cfi) {
1125 return false
1126 }
1127
1128 return c.SanitizePropDefined() &&
1129 !c.SanitizeNever() &&
1130 !c.IsSanitizerExplicitlyDisabled(cfi)
Inseob Kimc42f2f22020-07-29 20:32:10 +09001131}
1132
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001133type sanitizerSplitMutator struct {
1134 sanitizer SanitizerType
1135}
1136
1137// If an APEX is sanitized or not depends on whether it contains at least one
1138// sanitized module. Transition mutators cannot propagate information up the
1139// dependency graph this way, so we need an auxiliary mutator to do so.
1140func (s *sanitizerSplitMutator) markSanitizableApexesMutator(ctx android.TopDownMutatorContext) {
1141 if sanitizeable, ok := ctx.Module().(Sanitizeable); ok {
1142 enabled := sanitizeable.IsSanitizerEnabled(ctx.Config(), s.sanitizer.name())
1143 ctx.VisitDirectDeps(func(dep android.Module) {
1144 if c, ok := dep.(*Module); ok && c.sanitize.isSanitizerEnabled(s.sanitizer) {
Inseob Kimc42f2f22020-07-29 20:32:10 +09001145 enabled = true
Inseob Kimc42f2f22020-07-29 20:32:10 +09001146 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001147 })
1148
1149 if enabled {
1150 sanitizeable.EnableSanitizer(s.sanitizer.name())
1151 }
1152 }
1153}
1154
1155func (s *sanitizerSplitMutator) Split(ctx android.BaseModuleContext) []string {
1156 if c, ok := ctx.Module().(PlatformSanitizeable); ok && c.SanitizePropDefined() {
1157 if s.sanitizer == cfi && needsCfiForVendorSnapshot(ctx) {
1158 return []string{"", s.sanitizer.variationName()}
1159 }
1160
1161 // If the given sanitizer is not requested in the .bp file for a module, it
1162 // won't automatically build the sanitized variation.
1163 if !c.IsSanitizerEnabled(s.sanitizer) {
1164 return []string{""}
1165 }
1166
1167 if c.Binary() {
1168 // If a sanitizer is enabled for a binary, we do not build the version
1169 // without the sanitizer
1170 return []string{s.sanitizer.variationName()}
1171 } else if c.StaticallyLinked() || c.Header() {
1172 // For static libraries, we build both versions. Some Make modules
1173 // apparently depend on this behavior.
1174 return []string{"", s.sanitizer.variationName()}
1175 } else {
1176 // We only build the requested variation of dynamic libraries
1177 return []string{s.sanitizer.variationName()}
1178 }
1179 }
1180
1181 if _, ok := ctx.Module().(JniSanitizeable); ok {
1182 // TODO: this should call into JniSanitizable.IsSanitizerEnabledForJni but
1183 // that is short-circuited for now
1184 return []string{""}
1185 }
1186
1187 // If an APEX has a sanitized dependency, we build the APEX in the sanitized
1188 // variation. This is useful because such APEXes require extra dependencies.
1189 if sanitizeable, ok := ctx.Module().(Sanitizeable); ok {
1190 enabled := sanitizeable.IsSanitizerEnabled(ctx.Config(), s.sanitizer.name())
1191 if enabled {
1192 return []string{s.sanitizer.variationName()}
1193 } else {
1194 return []string{""}
1195 }
1196 }
1197
1198 if c, ok := ctx.Module().(*Module); ok {
1199 //TODO: When Rust modules have vendor support, enable this path for PlatformSanitizeable
1200
1201 // Check if it's a snapshot module supporting sanitizer
Justin Yun08270c62022-12-19 17:01:26 +09001202 if ss, ok := c.linker.(snapshotSanitizer); ok {
1203 if ss.isSanitizerAvailable(s.sanitizer) {
1204 return []string{"", s.sanitizer.variationName()}
1205 } else {
1206 return []string{""}
1207 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001208 }
1209 }
1210
1211 return []string{""}
1212}
1213
1214func (s *sanitizerSplitMutator) OutgoingTransition(ctx android.OutgoingTransitionContext, sourceVariation string) string {
1215 if c, ok := ctx.Module().(PlatformSanitizeable); ok {
1216 if !c.SanitizableDepTagChecker()(ctx.DepTag()) {
1217 // If the dependency is through a non-sanitizable tag, use the
1218 // non-sanitized variation
1219 return ""
1220 }
1221
1222 return sourceVariation
1223 } else if _, ok := ctx.Module().(JniSanitizeable); ok {
1224 // TODO: this should call into JniSanitizable.IsSanitizerEnabledForJni but
1225 // that is short-circuited for now
1226 return ""
1227 } else {
1228 // Otherwise, do not rock the boat.
1229 return sourceVariation
1230 }
1231}
1232
1233func (s *sanitizerSplitMutator) IncomingTransition(ctx android.IncomingTransitionContext, incomingVariation string) string {
1234 if d, ok := ctx.Module().(PlatformSanitizeable); ok {
1235 if dm, ok := ctx.Module().(*Module); ok {
Justin Yun39c30312022-11-23 16:20:12 +09001236 if ss, ok := dm.linker.(snapshotSanitizer); ok && ss.isSanitizerAvailable(s.sanitizer) {
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001237 return incomingVariation
Inseob Kimc42f2f22020-07-29 20:32:10 +09001238 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001239 }
1240
1241 if !d.SanitizePropDefined() ||
1242 d.SanitizeNever() ||
1243 d.IsSanitizerExplicitlyDisabled(s.sanitizer) ||
1244 !d.SanitizerSupported(s.sanitizer) {
1245 // If a module opts out of a sanitizer, use its non-sanitized variation
1246 return ""
1247 }
1248
1249 // Binaries are always built in the variation they requested.
1250 if d.Binary() {
1251 if d.IsSanitizerEnabled(s.sanitizer) {
1252 return s.sanitizer.variationName()
1253 } else {
1254 return ""
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +00001255 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001256 }
1257
1258 // If a shared library requests to be sanitized, it will be built for that
1259 // sanitizer. Otherwise, some sanitizers propagate through shared library
1260 // dependency edges, some do not.
1261 if !d.StaticallyLinked() && !d.Header() {
1262 if d.IsSanitizerEnabled(s.sanitizer) {
1263 return s.sanitizer.variationName()
1264 }
1265
Liz Kammerfd8a49f2022-10-31 10:31:11 -04001266 // Some sanitizers do not propagate to shared dependencies
1267 if !s.sanitizer.shouldPropagateToSharedLibraryDeps() {
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001268 return ""
1269 }
1270 }
1271
1272 // Static and header libraries inherit whether they are sanitized from the
1273 // module they are linked into
1274 return incomingVariation
1275 } else if d, ok := ctx.Module().(Sanitizeable); ok {
1276 // If an APEX contains a sanitized module, it will be built in the variation
1277 // corresponding to that sanitizer.
1278 enabled := d.IsSanitizerEnabled(ctx.Config(), s.sanitizer.name())
1279 if enabled {
1280 return s.sanitizer.variationName()
1281 }
1282
1283 return incomingVariation
1284 }
1285
1286 return ""
1287}
1288
1289func (s *sanitizerSplitMutator) Mutate(mctx android.BottomUpMutatorContext, variationName string) {
1290 sanitizerVariation := variationName == s.sanitizer.variationName()
1291
1292 if c, ok := mctx.Module().(PlatformSanitizeable); ok && c.SanitizePropDefined() {
1293 sanitizerEnabled := c.IsSanitizerEnabled(s.sanitizer)
1294
1295 oneMakeVariation := false
1296 if c.StaticallyLinked() || c.Header() {
1297 if s.sanitizer != cfi && s.sanitizer != scs && s.sanitizer != Hwasan {
1298 // These sanitizers export only one variation to Make. For the rest,
1299 // Make targets can depend on both the sanitized and non-sanitized
1300 // versions.
1301 oneMakeVariation = true
1302 }
1303 } else if !c.Binary() {
1304 // Shared library. These are the sanitizers that do propagate through shared
1305 // library dependencies and therefore can cause multiple variations of a
1306 // shared library to be built.
1307 if s.sanitizer != cfi && s.sanitizer != Hwasan && s.sanitizer != scs && s.sanitizer != Asan {
1308 oneMakeVariation = true
1309 }
1310 }
1311
1312 if oneMakeVariation {
1313 if sanitizerEnabled != sanitizerVariation {
1314 c.SetPreventInstall()
1315 c.SetHideFromMake()
1316 }
1317 }
1318
1319 if sanitizerVariation {
1320 c.SetSanitizer(s.sanitizer, true)
1321
1322 // CFI is incompatible with ASAN so disable it in ASAN variations
1323 if s.sanitizer.incompatibleWithCfi() {
1324 cfiSupported := mctx.Module().(PlatformSanitizeable).SanitizerSupported(cfi)
1325 if mctx.Device() && cfiSupported {
1326 c.SetSanitizer(cfi, false)
Jiyong Parkf97782b2019-02-13 20:28:58 +09001327 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001328 }
1329
1330 // locate the asan libraries under /data/asan
1331 if !c.Binary() && !c.StaticallyLinked() && !c.Header() && mctx.Device() && s.sanitizer == Asan && sanitizerEnabled {
1332 c.SetInSanitizerDir()
1333 }
1334
1335 if c.StaticallyLinked() && c.ExportedToMake() {
1336 if s.sanitizer == Hwasan {
1337 hwasanStaticLibs(mctx.Config()).add(c, c.Module().Name())
1338 } else if s.sanitizer == cfi {
1339 cfiStaticLibs(mctx.Config()).add(c, c.Module().Name())
1340 }
1341 }
1342 } else if c.IsSanitizerEnabled(s.sanitizer) {
1343 // Disable the sanitizer for the non-sanitized variation
1344 c.SetSanitizer(s.sanitizer, false)
1345 }
1346 } else if sanitizeable, ok := mctx.Module().(Sanitizeable); ok {
1347 // If an APEX has sanitized dependencies, it gets a few more dependencies
1348 if sanitizerVariation {
1349 sanitizeable.AddSanitizerDependencies(mctx, s.sanitizer.name())
1350 }
1351 } else if c, ok := mctx.Module().(*Module); ok {
Justin Yun39c30312022-11-23 16:20:12 +09001352 if ss, ok := c.linker.(snapshotSanitizer); ok && ss.isSanitizerAvailable(s.sanitizer) {
1353 if !ss.isUnsanitizedVariant() {
1354 // Snapshot sanitizer may have only one variantion.
1355 // Skip exporting the module if it already has a sanitizer variation.
1356 c.SetPreventInstall()
1357 c.SetHideFromMake()
1358 return
1359 }
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001360 c.linker.(snapshotSanitizer).setSanitizerVariation(s.sanitizer, sanitizerVariation)
1361
1362 // Export the static lib name to make
1363 if c.static() && c.ExportedToMake() {
Justin Yun39c30312022-11-23 16:20:12 +09001364 // use BaseModuleName which is the name for Make.
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001365 if s.sanitizer == cfi {
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001366 cfiStaticLibs(mctx.Config()).add(c, c.BaseModuleName())
Justin Yun39c30312022-11-23 16:20:12 +09001367 } else if s.sanitizer == Hwasan {
1368 hwasanStaticLibs(mctx.Config()).add(c, c.BaseModuleName())
Lukacs T. Berki6c716762022-06-13 20:50:39 +02001369 }
1370 }
Colin Cross16b23492016-01-06 14:41:07 -08001371 }
1372 }
1373}
1374
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001375func (c *Module) SanitizeNever() bool {
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001376 return Bool(c.sanitize.Properties.SanitizeMutated.Never)
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001377}
1378
1379func (c *Module) IsSanitizerExplicitlyDisabled(t SanitizerType) bool {
1380 return c.sanitize.isSanitizerExplicitlyDisabled(t)
1381}
1382
Ivan Lozano30c5db22018-02-21 15:49:20 -08001383// Propagate the ubsan minimal runtime dependency when there are integer overflow sanitized static dependencies.
Colin Cross6b753602018-06-21 13:03:07 -07001384func sanitizerRuntimeDepsMutator(mctx android.TopDownMutatorContext) {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001385 // Change this to PlatformSanitizable when/if non-cc modules support ubsan sanitizers.
Colin Cross6b753602018-06-21 13:03:07 -07001386 if c, ok := mctx.Module().(*Module); ok && c.sanitize != nil {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001387 isSanitizableDependencyTag := c.SanitizableDepTagChecker()
Colin Cross6b753602018-06-21 13:03:07 -07001388 mctx.WalkDeps(func(child, parent android.Module) bool {
1389 if !isSanitizableDependencyTag(mctx.OtherModuleDependencyTag(child)) {
1390 return false
1391 }
Ivan Lozano30c5db22018-02-21 15:49:20 -08001392
Inseob Kimeec88e12020-01-22 11:11:29 +09001393 d, ok := child.(*Module)
1394 if !ok || !d.static() {
1395 return false
1396 }
1397 if d.sanitize != nil {
Colin Cross6b753602018-06-21 13:03:07 -07001398 if enableMinimalRuntime(d.sanitize) {
1399 // If a static dependency is built with the minimal runtime,
1400 // make sure we include the ubsan minimal runtime.
1401 c.sanitize.Properties.MinimalRuntimeDep = true
Inseob Kim8471cda2019-11-15 09:59:12 +09001402 } else if enableUbsanRuntime(d.sanitize) {
Colin Cross6b753602018-06-21 13:03:07 -07001403 // If a static dependency runs with full ubsan diagnostics,
1404 // make sure we include the ubsan runtime.
1405 c.sanitize.Properties.UbsanRuntimeDep = true
Ivan Lozano30c5db22018-02-21 15:49:20 -08001406 }
Colin Cross0b908332019-06-19 23:00:20 -07001407
1408 if c.sanitize.Properties.MinimalRuntimeDep &&
1409 c.sanitize.Properties.UbsanRuntimeDep {
1410 // both flags that this mutator might set are true, so don't bother recursing
1411 return false
1412 }
1413
Ivan Lozano9ac32c72020-02-19 15:24:02 -05001414 if c.Os() == android.Linux {
1415 c.sanitize.Properties.BuiltinsDep = true
1416 }
1417
Colin Cross0b908332019-06-19 23:00:20 -07001418 return true
Colin Cross6b753602018-06-21 13:03:07 -07001419 }
Inseob Kimeec88e12020-01-22 11:11:29 +09001420
Jose Galmesf7294582020-11-13 12:07:36 -08001421 if p, ok := d.linker.(*snapshotLibraryDecorator); ok {
Inseob Kimeec88e12020-01-22 11:11:29 +09001422 if Bool(p.properties.Sanitize_minimal_dep) {
1423 c.sanitize.Properties.MinimalRuntimeDep = true
1424 }
1425 if Bool(p.properties.Sanitize_ubsan_dep) {
1426 c.sanitize.Properties.UbsanRuntimeDep = true
1427 }
1428 }
1429
1430 return false
Colin Cross6b753602018-06-21 13:03:07 -07001431 })
Ivan Lozano30c5db22018-02-21 15:49:20 -08001432 }
1433}
1434
Jiyong Park379de2f2018-12-19 02:47:14 +09001435// Add the dependency to the runtime library for each of the sanitizer variants
1436func sanitizerRuntimeMutator(mctx android.BottomUpMutatorContext) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001437 if c, ok := mctx.Module().(*Module); ok && c.sanitize != nil {
Pirama Arumuga Nainar6aa21022019-01-25 00:20:35 +00001438 if !c.Enabled() {
1439 return
1440 }
Jiyong Park379de2f2018-12-19 02:47:14 +09001441 var sanitizers []string
1442 var diagSanitizers []string
1443
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001444 sanProps := &c.sanitize.Properties.SanitizeMutated
1445
1446 if Bool(sanProps.All_undefined) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001447 sanitizers = append(sanitizers, "undefined")
1448 } else {
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001449 if Bool(sanProps.Undefined) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001450 sanitizers = append(sanitizers,
1451 "bool",
1452 "integer-divide-by-zero",
1453 "return",
1454 "returns-nonnull-attribute",
1455 "shift-exponent",
1456 "unreachable",
1457 "vla-bound",
1458 // TODO(danalbert): The following checks currently have compiler performance issues.
1459 //"alignment",
1460 //"bounds",
1461 //"enum",
1462 //"float-cast-overflow",
1463 //"float-divide-by-zero",
1464 //"nonnull-attribute",
1465 //"null",
1466 //"shift-base",
1467 //"signed-integer-overflow",
1468 // TODO(danalbert): Fix UB in libc++'s __tree so we can turn this on.
1469 // https://llvm.org/PR19302
1470 // http://reviews.llvm.org/D6974
1471 // "object-size",
1472 )
1473 }
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001474 sanitizers = append(sanitizers, sanProps.Misc_undefined...)
Jiyong Park379de2f2018-12-19 02:47:14 +09001475 }
1476
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001477 if Bool(sanProps.Diag.Undefined) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001478 diagSanitizers = append(diagSanitizers, "undefined")
1479 }
1480
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001481 diagSanitizers = append(diagSanitizers, sanProps.Diag.Misc_undefined...)
Jiyong Park379de2f2018-12-19 02:47:14 +09001482
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001483 if Bool(sanProps.Address) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001484 sanitizers = append(sanitizers, "address")
1485 diagSanitizers = append(diagSanitizers, "address")
1486 }
1487
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001488 if Bool(sanProps.Hwaddress) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001489 sanitizers = append(sanitizers, "hwaddress")
1490 }
1491
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001492 if Bool(sanProps.Thread) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001493 sanitizers = append(sanitizers, "thread")
1494 }
1495
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001496 if Bool(sanProps.Safestack) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001497 sanitizers = append(sanitizers, "safe-stack")
1498 }
1499
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001500 if Bool(sanProps.Cfi) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001501 sanitizers = append(sanitizers, "cfi")
1502
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001503 if Bool(sanProps.Diag.Cfi) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001504 diagSanitizers = append(diagSanitizers, "cfi")
1505 }
1506 }
1507
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001508 if Bool(sanProps.Integer_overflow) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001509 sanitizers = append(sanitizers, "unsigned-integer-overflow")
1510 sanitizers = append(sanitizers, "signed-integer-overflow")
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001511 if Bool(sanProps.Diag.Integer_overflow) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001512 diagSanitizers = append(diagSanitizers, "unsigned-integer-overflow")
1513 diagSanitizers = append(diagSanitizers, "signed-integer-overflow")
1514 }
1515 }
1516
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001517 if Bool(sanProps.Scudo) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001518 sanitizers = append(sanitizers, "scudo")
1519 }
1520
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001521 if Bool(sanProps.Scs) {
Jiyong Park379de2f2018-12-19 02:47:14 +09001522 sanitizers = append(sanitizers, "shadow-call-stack")
1523 }
1524
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001525 if Bool(sanProps.Memtag_heap) && c.Binary() {
Florian Mayerd8434a42022-08-31 20:57:03 +00001526 sanitizers = append(sanitizers, "memtag-heap")
1527 }
1528
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001529 if Bool(sanProps.Memtag_stack) {
Florian Mayerd8434a42022-08-31 20:57:03 +00001530 sanitizers = append(sanitizers, "memtag-stack")
Evgenii Stepanov193ac2e2020-04-28 15:09:12 -07001531 }
1532
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001533 if Bool(sanProps.Fuzzer) {
Mitch Phillips5a6ea6c2019-05-01 14:42:05 -07001534 sanitizers = append(sanitizers, "fuzzer-no-link")
1535 }
1536
Jiyong Park379de2f2018-12-19 02:47:14 +09001537 // Save the list of sanitizers. These will be used again when generating
1538 // the build rules (for Cflags, etc.)
1539 c.sanitize.Properties.Sanitizers = sanitizers
1540 c.sanitize.Properties.DiagSanitizers = diagSanitizers
1541
Ivan Lozanof3b190f2020-03-06 12:01:21 -05001542 // TODO(b/150822854) Hosts have a different default behavior and assume the runtime library is used.
1543 if c.Host() {
1544 diagSanitizers = sanitizers
1545 }
1546
Colin Crosse323a792023-02-15 13:57:57 -08001547 addStaticDeps := func(dep string, hideSymbols bool) {
Colin Cross06c80eb2022-02-10 10:34:19 -08001548 // If we're using snapshots, redirect to snapshot whenever possible
1549 snapshot := mctx.Provider(SnapshotInfoProvider).(SnapshotInfo)
Colin Crosse323a792023-02-15 13:57:57 -08001550 if lib, ok := snapshot.StaticLibs[dep]; ok {
1551 dep = lib
Colin Cross06c80eb2022-02-10 10:34:19 -08001552 }
1553
1554 // static executable gets static runtime libs
Colin Crosse323a792023-02-15 13:57:57 -08001555 depTag := libraryDependencyTag{Kind: staticLibraryDependency, unexportedSymbols: hideSymbols}
Colin Cross06c80eb2022-02-10 10:34:19 -08001556 variations := append(mctx.Target().Variations(),
1557 blueprint.Variation{Mutator: "link", Variation: "static"})
1558 if c.Device() {
1559 variations = append(variations, c.ImageVariation())
1560 }
1561 if c.UseSdk() {
1562 variations = append(variations,
1563 blueprint.Variation{Mutator: "sdk", Variation: "sdk"})
1564 }
Colin Crosse323a792023-02-15 13:57:57 -08001565 mctx.AddFarVariationDependencies(variations, depTag, dep)
Colin Cross06c80eb2022-02-10 10:34:19 -08001566 }
Colin Crosse323a792023-02-15 13:57:57 -08001567
1568 // Determine the runtime library required
1569 runtimeSharedLibrary := ""
1570 toolchain := c.toolchain(mctx)
1571 if Bool(sanProps.Address) {
Colin Crossb781d232023-02-15 12:40:20 -08001572 if toolchain.Musl() || (c.staticBinary() && toolchain.Bionic()) {
1573 // Use a static runtime for musl to match what clang does for glibc.
1574 addStaticDeps(config.AddressSanitizerStaticRuntimeLibrary(toolchain), false)
1575 addStaticDeps(config.AddressSanitizerCXXStaticRuntimeLibrary(toolchain), false)
1576 } else {
1577 runtimeSharedLibrary = config.AddressSanitizerRuntimeLibrary(toolchain)
1578 }
Colin Crosse323a792023-02-15 13:57:57 -08001579 } else if Bool(sanProps.Hwaddress) {
1580 if c.staticBinary() {
1581 addStaticDeps(config.HWAddressSanitizerStaticLibrary(toolchain), true)
1582 addStaticDeps("libdl", false)
1583 } else {
1584 runtimeSharedLibrary = config.HWAddressSanitizerRuntimeLibrary(toolchain)
1585 }
1586 } else if Bool(sanProps.Thread) {
1587 runtimeSharedLibrary = config.ThreadSanitizerRuntimeLibrary(toolchain)
1588 } else if Bool(sanProps.Scudo) {
1589 if len(diagSanitizers) == 0 && !c.sanitize.Properties.UbsanRuntimeDep {
1590 runtimeSharedLibrary = config.ScudoMinimalRuntimeLibrary(toolchain)
1591 } else {
1592 runtimeSharedLibrary = config.ScudoRuntimeLibrary(toolchain)
1593 }
1594 } else if len(diagSanitizers) > 0 || c.sanitize.Properties.UbsanRuntimeDep ||
1595 Bool(sanProps.Fuzzer) ||
1596 Bool(sanProps.Undefined) ||
1597 Bool(sanProps.All_undefined) {
1598 if toolchain.Musl() || (c.staticBinary() && toolchain.Bionic()) {
1599 // Use a static runtime for static binaries.
1600 // Also use a static runtime for musl to match
1601 // what clang does for glibc. Otherwise dlopening
1602 // libraries that depend on libclang_rt.ubsan_standalone.so
1603 // fails with:
1604 // Error relocating ...: initial-exec TLS resolves to dynamic definition
1605 addStaticDeps(config.UndefinedBehaviorSanitizerRuntimeLibrary(toolchain)+".static", true)
1606 } else {
1607 runtimeSharedLibrary = config.UndefinedBehaviorSanitizerRuntimeLibrary(toolchain)
1608 }
1609 }
1610
Colin Cross06c80eb2022-02-10 10:34:19 -08001611 if enableMinimalRuntime(c.sanitize) || c.sanitize.Properties.MinimalRuntimeDep {
Colin Crosse323a792023-02-15 13:57:57 -08001612 addStaticDeps(config.UndefinedBehaviorSanitizerMinimalRuntimeLibrary(toolchain), true)
Colin Cross06c80eb2022-02-10 10:34:19 -08001613 }
1614 if c.sanitize.Properties.BuiltinsDep {
Colin Crosse323a792023-02-15 13:57:57 -08001615 addStaticDeps(config.BuiltinsRuntimeLibrary(toolchain), true)
Colin Cross06c80eb2022-02-10 10:34:19 -08001616 }
1617
Colin Crosse323a792023-02-15 13:57:57 -08001618 if runtimeSharedLibrary != "" && (toolchain.Bionic() || toolchain.Musl() || c.sanitize.Properties.UbsanRuntimeDep) {
Ivan Lozano9ac32c72020-02-19 15:24:02 -05001619 // UBSan is supported on non-bionic linux host builds as well
Jiyong Park379de2f2018-12-19 02:47:14 +09001620
1621 // Adding dependency to the runtime library. We are using *FarVariation*
1622 // because the runtime libraries themselves are not mutated by sanitizer
1623 // mutators and thus don't have sanitizer variants whereas this module
1624 // has been already mutated.
1625 //
1626 // Note that by adding dependency with {static|shared}DepTag, the lib is
1627 // added to libFlags and LOCAL_SHARED_LIBRARIES by cc.Module
Colin Crosse323a792023-02-15 13:57:57 -08001628 if c.staticBinary() {
1629 // Most sanitizers are either disabled for static binaries or have already
1630 // handled the static binary case above through a direct call to addStaticDeps.
1631 // If not, treat the runtime shared library as a static library and hope for
1632 // the best.
1633 addStaticDeps(runtimeSharedLibrary, true)
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001634 } else if !c.static() && !c.Header() {
Colin Crosse0edaf92021-01-11 17:31:17 -08001635 // If we're using snapshots, redirect to snapshot whenever possible
1636 snapshot := mctx.Provider(SnapshotInfoProvider).(SnapshotInfo)
Colin Crosse323a792023-02-15 13:57:57 -08001637 if lib, ok := snapshot.SharedLibs[runtimeSharedLibrary]; ok {
1638 runtimeSharedLibrary = lib
Inseob Kimeec88e12020-01-22 11:11:29 +09001639 }
Colin Crosse0edaf92021-01-11 17:31:17 -08001640
Cindy Zhou18417cb2020-12-10 07:12:38 -08001641 // Skip apex dependency check for sharedLibraryDependency
1642 // when sanitizer diags are enabled. Skipping the check will allow
1643 // building with diag libraries without having to list the
1644 // dependency in Apex's allowed_deps file.
1645 diagEnabled := len(diagSanitizers) > 0
Jiyong Park3b1746a2019-01-29 11:15:04 +09001646 // dynamic executable and shared libs get shared runtime libs
Cindy Zhou18417cb2020-12-10 07:12:38 -08001647 depTag := libraryDependencyTag{
1648 Kind: sharedLibraryDependency,
1649 Order: earlyLibraryDependency,
1650
1651 skipApexAllowedDependenciesCheck: diagEnabled,
1652 }
Colin Cross42507332020-08-21 16:15:23 -07001653 variations := append(mctx.Target().Variations(),
1654 blueprint.Variation{Mutator: "link", Variation: "shared"})
1655 if c.Device() {
1656 variations = append(variations, c.ImageVariation())
1657 }
Colin Cross06c80eb2022-02-10 10:34:19 -08001658 if c.UseSdk() {
1659 variations = append(variations,
1660 blueprint.Variation{Mutator: "sdk", Variation: "sdk"})
1661 }
Colin Crosse323a792023-02-15 13:57:57 -08001662 AddSharedLibDependenciesWithVersions(mctx, c, variations, depTag, runtimeSharedLibrary, "", true)
Jiyong Park379de2f2018-12-19 02:47:14 +09001663 }
1664 // static lib does not have dependency to the runtime library. The
1665 // dependency will be added to the executables or shared libs using
1666 // the static lib.
1667 }
1668 }
1669}
1670
1671type Sanitizeable interface {
1672 android.Module
Lukacs T. Berki01a648a2022-06-17 08:59:37 +02001673 IsSanitizerEnabled(config android.Config, sanitizerName string) bool
Jiyong Parkf97782b2019-02-13 20:28:58 +09001674 EnableSanitizer(sanitizerName string)
Jooyung Han8ce8db92020-05-15 19:05:05 +09001675 AddSanitizerDependencies(ctx android.BottomUpMutatorContext, sanitizerName string)
Jiyong Park379de2f2018-12-19 02:47:14 +09001676}
1677
Muhammad Haseeb Ahmad7e744052022-03-25 22:50:53 +00001678type JniSanitizeable interface {
1679 android.Module
1680 IsSanitizerEnabledForJni(ctx android.BaseModuleContext, sanitizerName string) bool
1681}
1682
Ivan Lozanod7586b62021-04-01 09:49:36 -04001683func (c *Module) MinimalRuntimeDep() bool {
1684 return c.sanitize.Properties.MinimalRuntimeDep
1685}
1686
1687func (c *Module) UbsanRuntimeDep() bool {
1688 return c.sanitize.Properties.UbsanRuntimeDep
1689}
1690
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001691func (c *Module) SanitizePropDefined() bool {
1692 return c.sanitize != nil
1693}
1694
1695func (c *Module) IsSanitizerEnabled(t SanitizerType) bool {
1696 return c.sanitize.isSanitizerEnabled(t)
1697}
1698
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001699func (c *Module) StaticallyLinked() bool {
1700 return c.static()
1701}
1702
1703func (c *Module) SetInSanitizerDir() {
1704 if c.sanitize != nil {
1705 c.sanitize.Properties.InSanitizerDir = true
1706 }
1707}
1708
1709func (c *Module) SetSanitizer(t SanitizerType, b bool) {
1710 if c.sanitize != nil {
1711 c.sanitize.SetSanitizer(t, b)
1712 }
1713}
1714
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001715var _ PlatformSanitizeable = (*Module)(nil)
1716
Inseob Kim74d25562020-08-04 00:41:38 +09001717type sanitizerStaticLibsMap struct {
1718 // libsMap contains one list of modules per each image and each arch.
1719 // e.g. libs[vendor]["arm"] contains arm modules installed to vendor
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001720 libsMap map[ImageVariantType]map[string][]string
Inseob Kim74d25562020-08-04 00:41:38 +09001721 libsMapLock sync.Mutex
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001722 sanitizerType SanitizerType
Inseob Kim74d25562020-08-04 00:41:38 +09001723}
1724
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001725func newSanitizerStaticLibsMap(t SanitizerType) *sanitizerStaticLibsMap {
Inseob Kim74d25562020-08-04 00:41:38 +09001726 return &sanitizerStaticLibsMap{
1727 sanitizerType: t,
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001728 libsMap: make(map[ImageVariantType]map[string][]string),
Inseob Kim74d25562020-08-04 00:41:38 +09001729 }
1730}
1731
1732// Add the current module to sanitizer static libs maps
1733// Each module should pass its exported name as names of Make and Soong can differ.
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001734func (s *sanitizerStaticLibsMap) add(c LinkableInterface, name string) {
1735 image := GetImageVariantType(c)
1736 arch := c.Module().Target().Arch.ArchType.String()
Inseob Kim74d25562020-08-04 00:41:38 +09001737
1738 s.libsMapLock.Lock()
1739 defer s.libsMapLock.Unlock()
1740
1741 if _, ok := s.libsMap[image]; !ok {
1742 s.libsMap[image] = make(map[string][]string)
1743 }
1744
1745 s.libsMap[image][arch] = append(s.libsMap[image][arch], name)
1746}
1747
1748// Exports makefile variables in the following format:
1749// SOONG_{sanitizer}_{image}_{arch}_STATIC_LIBRARIES
1750// e.g. SOONG_cfi_core_x86_STATIC_LIBRARIES
1751// These are to be used by use_soong_sanitized_static_libraries.
1752// See build/make/core/binary.mk for more details.
1753func (s *sanitizerStaticLibsMap) exportToMake(ctx android.MakeVarsContext) {
Cole Faust18994c72023-02-28 16:02:16 -08001754 for _, image := range android.SortedKeys(s.libsMap) {
Ivan Lozano3968d8f2020-12-14 11:27:52 -05001755 archMap := s.libsMap[ImageVariantType(image)]
Cole Faust18994c72023-02-28 16:02:16 -08001756 for _, arch := range android.SortedKeys(archMap) {
Inseob Kim74d25562020-08-04 00:41:38 +09001757 libs := archMap[arch]
1758 sort.Strings(libs)
1759
1760 key := fmt.Sprintf(
1761 "SOONG_%s_%s_%s_STATIC_LIBRARIES",
1762 s.sanitizerType.variationName(),
1763 image, // already upper
1764 arch)
1765
1766 ctx.Strict(key, strings.Join(libs, " "))
1767 }
1768 }
1769}
1770
Colin Cross571cccf2019-02-04 11:22:08 -08001771var cfiStaticLibsKey = android.NewOnceKey("cfiStaticLibs")
1772
Inseob Kim74d25562020-08-04 00:41:38 +09001773func cfiStaticLibs(config android.Config) *sanitizerStaticLibsMap {
Colin Cross571cccf2019-02-04 11:22:08 -08001774 return config.Once(cfiStaticLibsKey, func() interface{} {
Inseob Kim74d25562020-08-04 00:41:38 +09001775 return newSanitizerStaticLibsMap(cfi)
1776 }).(*sanitizerStaticLibsMap)
Vishwath Mohane7128792017-11-17 11:08:10 -08001777}
1778
Colin Cross571cccf2019-02-04 11:22:08 -08001779var hwasanStaticLibsKey = android.NewOnceKey("hwasanStaticLibs")
1780
Inseob Kim74d25562020-08-04 00:41:38 +09001781func hwasanStaticLibs(config android.Config) *sanitizerStaticLibsMap {
Colin Cross571cccf2019-02-04 11:22:08 -08001782 return config.Once(hwasanStaticLibsKey, func() interface{} {
Tri Vo6eafc362021-04-01 11:29:09 -07001783 return newSanitizerStaticLibsMap(Hwasan)
Inseob Kim74d25562020-08-04 00:41:38 +09001784 }).(*sanitizerStaticLibsMap)
Jiyong Park1d1119f2019-07-29 21:27:18 +09001785}
1786
Ivan Lozano30c5db22018-02-21 15:49:20 -08001787func enableMinimalRuntime(sanitize *sanitize) bool {
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001788 if sanitize.isSanitizerEnabled(Asan) {
1789 return false
1790 } else if sanitize.isSanitizerEnabled(Hwasan) {
1791 return false
1792 } else if sanitize.isSanitizerEnabled(Fuzzer) {
1793 return false
Ivan Lozano30c5db22018-02-21 15:49:20 -08001794 }
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001795
1796 if enableUbsanRuntime(sanitize) {
1797 return false
1798 }
1799
1800 sanitizeProps := &sanitize.Properties.SanitizeMutated
1801 if Bool(sanitizeProps.Diag.Cfi) {
1802 return false
1803 }
1804
1805 return Bool(sanitizeProps.Integer_overflow) ||
1806 len(sanitizeProps.Misc_undefined) > 0 ||
1807 Bool(sanitizeProps.Undefined) ||
1808 Bool(sanitizeProps.All_undefined)
Ivan Lozano30c5db22018-02-21 15:49:20 -08001809}
1810
Ivan Lozanod7586b62021-04-01 09:49:36 -04001811func (m *Module) UbsanRuntimeNeeded() bool {
1812 return enableUbsanRuntime(m.sanitize)
1813}
1814
1815func (m *Module) MinimalRuntimeNeeded() bool {
1816 return enableMinimalRuntime(m.sanitize)
1817}
1818
Inseob Kim8471cda2019-11-15 09:59:12 +09001819func enableUbsanRuntime(sanitize *sanitize) bool {
Liz Kammer2c1d6aa2022-10-03 15:07:37 -04001820 sanitizeProps := &sanitize.Properties.SanitizeMutated
1821 return Bool(sanitizeProps.Diag.Integer_overflow) ||
1822 Bool(sanitizeProps.Diag.Undefined) ||
1823 len(sanitizeProps.Diag.Misc_undefined) > 0
Inseob Kim8471cda2019-11-15 09:59:12 +09001824}
1825
Vishwath Mohane7128792017-11-17 11:08:10 -08001826func cfiMakeVarsProvider(ctx android.MakeVarsContext) {
Inseob Kim74d25562020-08-04 00:41:38 +09001827 cfiStaticLibs(ctx.Config()).exportToMake(ctx)
Vishwath Mohane7128792017-11-17 11:08:10 -08001828}
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -07001829
1830func hwasanMakeVarsProvider(ctx android.MakeVarsContext) {
Inseob Kim74d25562020-08-04 00:41:38 +09001831 hwasanStaticLibs(ctx.Config()).exportToMake(ctx)
Evgenii Stepanovd97a6e92018-08-02 16:19:13 -07001832}
Trevor Radcliffe4f95ee92023-01-19 16:02:47 +00001833
1834func BazelCcSanitizerToolchainVars(config android.Config) string {
1835 return android.BazelToolchainVars(config, exportedVars)
1836}