blob: 6ab66997ce46636dff1d79f990f3f475ff05b11b [file] [log] [blame]
Colin Cross16b23492016-01-06 14:41:07 -08001// Copyright 2016 Google Inc. All rights reserved.
2//
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7// http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14
15package cc
16
17import (
18 "fmt"
19 "strings"
20
21 "github.com/google/blueprint"
22
Colin Cross635c3b02016-05-18 15:37:25 -070023 "android/soong/android"
Evgenii Stepanovaf36db12016-08-15 14:18:24 -070024 "android/soong/cc/config"
Colin Cross16b23492016-01-06 14:41:07 -080025)
26
Dan Willemsencbceaab2016-10-13 16:44:07 -070027const (
Dan Willemsen78ffeea2016-10-20 18:46:48 -070028 asanCflags = "-fno-omit-frame-pointer"
Dan Willemsencbceaab2016-10-13 16:44:07 -070029 asanLdflags = "-Wl,-u,__asan_preinit"
Dan Willemsen78ffeea2016-10-20 18:46:48 -070030 asanLibs = "libasan"
Dan Willemsencbceaab2016-10-13 16:44:07 -070031)
32
Colin Cross16b23492016-01-06 14:41:07 -080033type sanitizerType int
34
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070035func boolPtr(v bool) *bool {
36 if v {
37 return &v
38 } else {
39 return nil
40 }
41}
42
Colin Cross16b23492016-01-06 14:41:07 -080043const (
44 asan sanitizerType = iota + 1
45 tsan
46)
47
48func (t sanitizerType) String() string {
49 switch t {
50 case asan:
51 return "asan"
52 case tsan:
53 return "tsan"
54 default:
55 panic(fmt.Errorf("unknown sanitizerType %d", t))
56 }
57}
58
59type SanitizeProperties struct {
60 // enable AddressSanitizer, ThreadSanitizer, or UndefinedBehaviorSanitizer
61 Sanitize struct {
62 Never bool `android:"arch_variant"`
63
64 // main sanitizers
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070065 Address *bool `android:"arch_variant"`
66 Thread *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080067
68 // local sanitizers
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070069 Undefined *bool `android:"arch_variant"`
70 All_undefined *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080071 Misc_undefined []string `android:"arch_variant"`
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -070072 Coverage *bool `android:"arch_variant"`
73 Safestack *bool `android:"arch_variant"`
Evgenii Stepanov1e405e12016-08-16 15:39:54 -070074 Cfi *bool `android:"arch_variant"`
Colin Cross16b23492016-01-06 14:41:07 -080075
Evgenii Stepanov1e405e12016-08-16 15:39:54 -070076 // Sanitizers to run in the diagnostic mode (as opposed to the release mode).
77 // Replaces abort() on error with a human-readable error message.
78 // Address and Thread sanitizers always run in diagnostic mode.
79 Diag struct {
80 Undefined *bool `android:"arch_variant"`
81 Cfi *bool `android:"arch_variant"`
82 }
83
84 // value to pass to -fsanitize-recover=
Colin Cross16b23492016-01-06 14:41:07 -080085 Recover []string
86
87 // value to pass to -fsanitize-blacklist
88 Blacklist *string
89 } `android:"arch_variant"`
90
91 SanitizerEnabled bool `blueprint:"mutated"`
92 SanitizeDep bool `blueprint:"mutated"`
Colin Cross30d5f512016-05-03 18:02:42 -070093 InData bool `blueprint:"mutated"`
Colin Cross16b23492016-01-06 14:41:07 -080094}
95
96type sanitize struct {
97 Properties SanitizeProperties
98}
99
100func (sanitize *sanitize) props() []interface{} {
101 return []interface{}{&sanitize.Properties}
102}
103
104func (sanitize *sanitize) begin(ctx BaseModuleContext) {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700105 s := &sanitize.Properties.Sanitize
106
Colin Cross16b23492016-01-06 14:41:07 -0800107 // Don't apply sanitizers to NDK code.
108 if ctx.sdk() {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700109 s.Never = true
Colin Cross16b23492016-01-06 14:41:07 -0800110 }
111
112 // Never always wins.
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700113 if s.Never {
Colin Cross16b23492016-01-06 14:41:07 -0800114 return
115 }
116
Colin Cross16b23492016-01-06 14:41:07 -0800117 var globalSanitizers []string
118 if ctx.clang() {
119 if ctx.Host() {
120 globalSanitizers = ctx.AConfig().SanitizeHost()
121 } else {
Colin Cross23ae82a2016-11-02 14:34:39 -0700122 arches := ctx.AConfig().SanitizeDeviceArch()
123 if len(arches) == 0 || inList(ctx.Arch().ArchType.Name, arches) {
124 globalSanitizers = ctx.AConfig().SanitizeDevice()
125 }
Colin Cross16b23492016-01-06 14:41:07 -0800126 }
127 }
128
Colin Cross16b23492016-01-06 14:41:07 -0800129 if len(globalSanitizers) > 0 {
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000130 var found bool
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700131 if found, globalSanitizers = removeFromList("undefined", globalSanitizers); found && s.All_undefined == nil {
132 s.All_undefined = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000133 }
Colin Cross16b23492016-01-06 14:41:07 -0800134
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700135 if found, globalSanitizers = removeFromList("default-ub", globalSanitizers); found && s.Undefined == nil {
136 s.Undefined = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000137 }
138
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700139 if found, globalSanitizers = removeFromList("address", globalSanitizers); found && s.Address == nil {
140 s.Address = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000141 }
142
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700143 if found, globalSanitizers = removeFromList("thread", globalSanitizers); found && s.Thread == nil {
144 s.Thread = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000145 }
146
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700147 if found, globalSanitizers = removeFromList("coverage", globalSanitizers); found && s.Coverage == nil {
148 s.Coverage = boolPtr(true)
149 }
150
151 if found, globalSanitizers = removeFromList("safe-stack", globalSanitizers); found && s.Safestack == nil {
152 s.Safestack = boolPtr(true)
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000153 }
154
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700155 if found, globalSanitizers = removeFromList("cfi", globalSanitizers); found && s.Cfi == nil {
156 s.Cfi = boolPtr(true)
157 }
158
Evgenii Stepanov05bafd32016-07-07 17:38:41 +0000159 if len(globalSanitizers) > 0 {
160 ctx.ModuleErrorf("unknown global sanitizer option %s", globalSanitizers[0])
161 }
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700162 }
Colin Cross3c344ef2016-07-18 15:44:56 -0700163
Vishwath Mohan1b017a72017-01-19 13:54:55 -0800164 if !ctx.AConfig().EnableCFI() {
165 s.Cfi = nil
166 s.Diag.Cfi = nil
167 }
168
Colin Cross3c344ef2016-07-18 15:44:56 -0700169 if ctx.staticBinary() {
170 s.Address = nil
Colin Cross91169fe2016-08-11 15:54:20 -0700171 s.Coverage = nil
Colin Cross3c344ef2016-07-18 15:44:56 -0700172 s.Thread = nil
Colin Cross16b23492016-01-06 14:41:07 -0800173 }
174
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700175 if Bool(s.All_undefined) {
176 s.Undefined = nil
177 }
178
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700179 if !ctx.toolchain().Is64Bit() {
180 // TSAN and SafeStack are not supported on 32-bit architectures
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700181 s.Thread = nil
182 s.Safestack = nil
Colin Cross16b23492016-01-06 14:41:07 -0800183 // TODO(ccross): error for compile_multilib = "32"?
184 }
185
Colin Cross3c344ef2016-07-18 15:44:56 -0700186 if Bool(s.All_undefined) || Bool(s.Undefined) || Bool(s.Address) ||
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700187 Bool(s.Thread) || Bool(s.Coverage) || Bool(s.Safestack) || Bool(s.Cfi) {
Colin Cross3c344ef2016-07-18 15:44:56 -0700188 sanitize.Properties.SanitizerEnabled = true
189 }
190
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700191 if Bool(s.Coverage) {
192 if !Bool(s.Address) {
Colin Cross16b23492016-01-06 14:41:07 -0800193 ctx.ModuleErrorf(`Use of "coverage" also requires "address"`)
194 }
195 }
196}
197
198func (sanitize *sanitize) deps(ctx BaseModuleContext, deps Deps) Deps {
199 if !sanitize.Properties.SanitizerEnabled { // || c.static() {
200 return deps
201 }
202
203 if ctx.Device() {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700204 if Bool(sanitize.Properties.Sanitize.Address) {
Dan Willemsencbceaab2016-10-13 16:44:07 -0700205 deps.StaticLibs = append(deps.StaticLibs, asanLibs)
Colin Cross16b23492016-01-06 14:41:07 -0800206 }
Colin Cross263abbd2016-07-15 13:10:48 -0700207 if Bool(sanitize.Properties.Sanitize.Address) || Bool(sanitize.Properties.Sanitize.Thread) {
208 deps.SharedLibs = append(deps.SharedLibs, "libdl")
209 }
Colin Cross16b23492016-01-06 14:41:07 -0800210 }
211
212 return deps
213}
214
215func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags) Flags {
216 if !sanitize.Properties.SanitizerEnabled {
217 return flags
218 }
219
220 if !ctx.clang() {
221 ctx.ModuleErrorf("Use of sanitizers requires clang")
222 }
223
224 var sanitizers []string
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700225 var diagSanitizers []string
Colin Cross16b23492016-01-06 14:41:07 -0800226
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700227 if Bool(sanitize.Properties.Sanitize.All_undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800228 sanitizers = append(sanitizers, "undefined")
229 if ctx.Device() {
230 ctx.ModuleErrorf("ubsan is not yet supported on the device")
231 }
232 } else {
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700233 if Bool(sanitize.Properties.Sanitize.Undefined) {
Colin Cross16b23492016-01-06 14:41:07 -0800234 sanitizers = append(sanitizers,
235 "bool",
236 "integer-divide-by-zero",
237 "return",
238 "returns-nonnull-attribute",
239 "shift-exponent",
240 "unreachable",
241 "vla-bound",
242 // TODO(danalbert): The following checks currently have compiler performance issues.
243 //"alignment",
244 //"bounds",
245 //"enum",
246 //"float-cast-overflow",
247 //"float-divide-by-zero",
248 //"nonnull-attribute",
249 //"null",
250 //"shift-base",
251 //"signed-integer-overflow",
252 // TODO(danalbert): Fix UB in libc++'s __tree so we can turn this on.
253 // https://llvm.org/PR19302
254 // http://reviews.llvm.org/D6974
255 // "object-size",
256 )
257 }
258 sanitizers = append(sanitizers, sanitize.Properties.Sanitize.Misc_undefined...)
259 }
260
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700261 if Bool(sanitize.Properties.Sanitize.Diag.Undefined) &&
262 (Bool(sanitize.Properties.Sanitize.All_undefined) ||
263 Bool(sanitize.Properties.Sanitize.Undefined) ||
264 len(sanitize.Properties.Sanitize.Misc_undefined) > 0) {
265 diagSanitizers = append(diagSanitizers, "undefined")
266 }
267
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700268 if Bool(sanitize.Properties.Sanitize.Address) {
Colin Cross635c3b02016-05-18 15:37:25 -0700269 if ctx.Arch().ArchType == android.Arm {
Colin Cross16b23492016-01-06 14:41:07 -0800270 // Frame pointer based unwinder in ASan requires ARM frame setup.
271 // TODO: put in flags?
272 flags.RequiredInstructionSet = "arm"
273 }
Dan Willemsencbceaab2016-10-13 16:44:07 -0700274 flags.CFlags = append(flags.CFlags, asanCflags)
275 flags.LdFlags = append(flags.LdFlags, asanLdflags)
Colin Cross16b23492016-01-06 14:41:07 -0800276
277 // ASan runtime library must be the first in the link order.
Evgenii Stepanovaf36db12016-08-15 14:18:24 -0700278 runtimeLibrary := config.AddressSanitizerRuntimeLibrary(ctx.toolchain())
Colin Cross16b23492016-01-06 14:41:07 -0800279 if runtimeLibrary != "" {
Colin Crossb98c8b02016-07-29 13:44:28 -0700280 flags.libFlags = append([]string{"${config.ClangAsanLibDir}/" + runtimeLibrary}, flags.libFlags...)
Colin Cross16b23492016-01-06 14:41:07 -0800281 }
282 if ctx.Host() {
283 // -nodefaultlibs (provided with libc++) prevents the driver from linking
284 // libraries needed with -fsanitize=address. http://b/18650275 (WAI)
285 flags.LdFlags = append(flags.LdFlags, "-lm", "-lpthread")
286 flags.LdFlags = append(flags.LdFlags, "-Wl,--no-as-needed")
Colin Cross46974e22016-10-20 12:41:14 -0700287 // Host ASAN only links symbols in the final executable, so
288 // there will always be undefined symbols in intermediate libraries.
289 _, flags.LdFlags = removeFromList("-Wl,--no-undefined", flags.LdFlags)
Colin Cross16b23492016-01-06 14:41:07 -0800290 } else {
291 flags.CFlags = append(flags.CFlags, "-mllvm", "-asan-globals=0")
292 flags.DynamicLinker = "/system/bin/linker_asan"
293 if flags.Toolchain.Is64Bit() {
294 flags.DynamicLinker += "64"
295 }
296 }
297 sanitizers = append(sanitizers, "address")
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700298 diagSanitizers = append(diagSanitizers, "address")
Colin Cross16b23492016-01-06 14:41:07 -0800299 }
300
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700301 if Bool(sanitize.Properties.Sanitize.Coverage) {
Colin Cross16b23492016-01-06 14:41:07 -0800302 flags.CFlags = append(flags.CFlags, "-fsanitize-coverage=edge,indirect-calls,8bit-counters,trace-cmp")
303 }
304
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700305 if Bool(sanitize.Properties.Sanitize.Safestack) {
Evgenii Stepanov0a8a0d02016-05-12 13:54:53 -0700306 sanitizers = append(sanitizers, "safe-stack")
307 }
308
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700309 if Bool(sanitize.Properties.Sanitize.Cfi) {
310 sanitizers = append(sanitizers, "cfi")
311 cfiFlags := []string{"-flto", "-fsanitize=cfi", "-fsanitize-cfi-cross-dso"}
312 flags.CFlags = append(flags.CFlags, cfiFlags...)
313 flags.CFlags = append(flags.CFlags, "-fvisibility=default")
314 flags.LdFlags = append(flags.LdFlags, cfiFlags...)
315 // FIXME: revert the __cfi_check flag when clang is updated to r280031.
316 flags.LdFlags = append(flags.LdFlags, "-Wl,-plugin-opt,O1", "-Wl,-export-dynamic-symbol=__cfi_check")
317 if Bool(sanitize.Properties.Sanitize.Diag.Cfi) {
318 diagSanitizers = append(diagSanitizers, "cfi")
319 }
320 }
321
Colin Cross16b23492016-01-06 14:41:07 -0800322 if sanitize.Properties.Sanitize.Recover != nil {
323 flags.CFlags = append(flags.CFlags, "-fsanitize-recover="+
324 strings.Join(sanitize.Properties.Sanitize.Recover, ","))
325 }
326
327 if len(sanitizers) > 0 {
328 sanitizeArg := "-fsanitize=" + strings.Join(sanitizers, ",")
329 flags.CFlags = append(flags.CFlags, sanitizeArg)
330 if ctx.Host() {
331 flags.CFlags = append(flags.CFlags, "-fno-sanitize-recover=all")
332 flags.LdFlags = append(flags.LdFlags, sanitizeArg)
333 flags.LdFlags = append(flags.LdFlags, "-lrt", "-ldl")
334 } else {
Colin Cross263abbd2016-07-15 13:10:48 -0700335 flags.CFlags = append(flags.CFlags, "-fsanitize-trap=all", "-ftrap-function=abort")
Colin Cross16b23492016-01-06 14:41:07 -0800336 }
337 }
338
Evgenii Stepanov1e405e12016-08-16 15:39:54 -0700339 if len(diagSanitizers) > 0 {
340 flags.CFlags = append(flags.CFlags, "-fno-sanitize-trap="+strings.Join(diagSanitizers, ","))
341 }
342 // FIXME: enable RTTI if diag + (cfi or vptr)
343
344 // Link a runtime library if needed.
345 runtimeLibrary := ""
346 if Bool(sanitize.Properties.Sanitize.Address) {
347 runtimeLibrary = config.AddressSanitizerRuntimeLibrary(ctx.toolchain())
348 } else if len(diagSanitizers) > 0 {
349 runtimeLibrary = config.UndefinedBehaviorSanitizerRuntimeLibrary(ctx.toolchain())
350 }
351
352 // ASan runtime library must be the first in the link order.
353 if runtimeLibrary != "" {
354 flags.libFlags = append([]string{"${config.ClangAsanLibDir}/" + runtimeLibrary}, flags.libFlags...)
355 }
356
Colin Cross635c3b02016-05-18 15:37:25 -0700357 blacklist := android.OptionalPathForModuleSrc(ctx, sanitize.Properties.Sanitize.Blacklist)
Colin Cross16b23492016-01-06 14:41:07 -0800358 if blacklist.Valid() {
359 flags.CFlags = append(flags.CFlags, "-fsanitize-blacklist="+blacklist.String())
360 flags.CFlagsDeps = append(flags.CFlagsDeps, blacklist.Path())
361 }
362
363 return flags
364}
365
Colin Cross30d5f512016-05-03 18:02:42 -0700366func (sanitize *sanitize) inData() bool {
367 return sanitize.Properties.InData
368}
369
Colin Cross16b23492016-01-06 14:41:07 -0800370func (sanitize *sanitize) Sanitizer(t sanitizerType) bool {
371 if sanitize == nil {
372 return false
373 }
374
375 switch t {
376 case asan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700377 return Bool(sanitize.Properties.Sanitize.Address)
Colin Cross16b23492016-01-06 14:41:07 -0800378 case tsan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700379 return Bool(sanitize.Properties.Sanitize.Thread)
Colin Cross16b23492016-01-06 14:41:07 -0800380 default:
381 panic(fmt.Errorf("unknown sanitizerType %d", t))
382 }
383}
384
385func (sanitize *sanitize) SetSanitizer(t sanitizerType, b bool) {
386 switch t {
387 case asan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700388 sanitize.Properties.Sanitize.Address = boolPtr(b)
Colin Cross91169fe2016-08-11 15:54:20 -0700389 if !b {
390 sanitize.Properties.Sanitize.Coverage = nil
391 }
Colin Cross16b23492016-01-06 14:41:07 -0800392 case tsan:
Evgenii Stepanovfcfe56d2016-07-07 10:54:07 -0700393 sanitize.Properties.Sanitize.Thread = boolPtr(b)
Colin Cross16b23492016-01-06 14:41:07 -0800394 default:
395 panic(fmt.Errorf("unknown sanitizerType %d", t))
396 }
397 if b {
398 sanitize.Properties.SanitizerEnabled = true
399 }
400}
401
402// Propagate asan requirements down from binaries
Colin Cross635c3b02016-05-18 15:37:25 -0700403func sanitizerDepsMutator(t sanitizerType) func(android.TopDownMutatorContext) {
404 return func(mctx android.TopDownMutatorContext) {
Colin Cross16b23492016-01-06 14:41:07 -0800405 if c, ok := mctx.Module().(*Module); ok && c.sanitize.Sanitizer(t) {
406 mctx.VisitDepsDepthFirst(func(module blueprint.Module) {
407 if d, ok := mctx.Module().(*Module); ok && c.sanitize != nil &&
408 !c.sanitize.Properties.Sanitize.Never {
409 d.sanitize.Properties.SanitizeDep = true
410 }
411 })
412 }
413 }
414}
415
416// Create asan variants for modules that need them
Colin Cross635c3b02016-05-18 15:37:25 -0700417func sanitizerMutator(t sanitizerType) func(android.BottomUpMutatorContext) {
418 return func(mctx android.BottomUpMutatorContext) {
Colin Cross16b23492016-01-06 14:41:07 -0800419 if c, ok := mctx.Module().(*Module); ok && c.sanitize != nil {
Colin Crossb916a382016-07-29 17:28:03 -0700420 if c.isDependencyRoot() && c.sanitize.Sanitizer(t) {
Colin Cross30d5f512016-05-03 18:02:42 -0700421 modules := mctx.CreateVariations(t.String())
422 modules[0].(*Module).sanitize.SetSanitizer(t, true)
Colin Cross16b23492016-01-06 14:41:07 -0800423 } else if c.sanitize.Properties.SanitizeDep {
Colin Crossb0f28952016-09-19 16:46:53 -0700424 modules := mctx.CreateVariations("", t.String())
425 modules[0].(*Module).sanitize.SetSanitizer(t, false)
426 modules[1].(*Module).sanitize.SetSanitizer(t, true)
427 modules[0].(*Module).sanitize.Properties.SanitizeDep = false
428 modules[1].(*Module).sanitize.Properties.SanitizeDep = false
429 if mctx.Device() {
Colin Crossb36ab1a2016-05-25 12:35:53 -0700430 modules[1].(*Module).sanitize.Properties.InData = true
Colin Crossb0f28952016-09-19 16:46:53 -0700431 } else {
432 modules[0].(*Module).Properties.PreventInstall = true
433 }
434 if mctx.AConfig().EmbeddedInMake() {
435 modules[0].(*Module).Properties.HideFromMake = true
Colin Cross30d5f512016-05-03 18:02:42 -0700436 }
Colin Cross16b23492016-01-06 14:41:07 -0800437 }
438 c.sanitize.Properties.SanitizeDep = false
439 }
440 }
441}