StrixOS/build_soong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge changes If89b7d0b,I630c06f0,Id861a62b,If71bb468 am: 1a0e2d20b3

Browse Source 
Original change: https://android-review.googlesource.com/c/platform/build/soong/+/1749407

Change-Id: If50ef28db4d9d6e821119bf4ae669fd43c31bef5
This commit is contained in:
Liz Kammer
2021-07-09 21:02:44 +00:00
committed by Automerger Merge Worker
parent 314e9e6423 1a0e2d20b3
commit 60cd3b9609
3 changed files with 286 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
cc/cc.go
View File

@@ -53,25 +53,9 @@ func RegisterCCBuildComponents(ctx android.RegistrationContext) {
}) })
ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) { ctx.PostDepsMutators(func(ctx android.RegisterMutatorsContext) {
ctx.TopDown("asan_deps", sanitizerDepsMutator(Asan)) for _, san := range Sanitizers {
ctx.BottomUp("asan", sanitizerMutator(Asan)).Parallel() san.registerMutators(ctx)
}
ctx.TopDown("hwasan_deps", sanitizerDepsMutator(Hwasan))
ctx.BottomUp("hwasan", sanitizerMutator(Hwasan)).Parallel()
ctx.TopDown("fuzzer_deps", sanitizerDepsMutator(Fuzzer))
ctx.BottomUp("fuzzer", sanitizerMutator(Fuzzer)).Parallel()
// cfi mutator shouldn't run before sanitizers that return true for
// incompatibleWithCfi()
ctx.TopDown("cfi_deps", sanitizerDepsMutator(cfi))
ctx.BottomUp("cfi", sanitizerMutator(cfi)).Parallel()
ctx.TopDown("scs_deps", sanitizerDepsMutator(scs))
ctx.BottomUp("scs", sanitizerMutator(scs)).Parallel()
ctx.TopDown("tsan_deps", sanitizerDepsMutator(tsan))
ctx.BottomUp("tsan", sanitizerMutator(tsan)).Parallel()
ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel() ctx.TopDown("sanitize_runtime_deps", sanitizerRuntimeDepsMutator).Parallel()
ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel() ctx.BottomUp("sanitize_runtime", sanitizerRuntimeMutator).Parallel()

115
cc/sanitize.go
View File

@@ -79,12 +79,23 @@ const (
Hwasan Hwasan
tsan tsan
intOverflow intOverflow
cfi
scs scs
Fuzzer Fuzzer
memtag_heap memtag_heap
cfi // cfi is last to prevent it running before incompatible mutators
) )
var Sanitizers = []SanitizerType{
Asan,
Hwasan,
tsan,
intOverflow,
scs,
Fuzzer,
memtag_heap,
cfi, // cfi is last to prevent it running before incompatible mutators
}
// Name of the sanitizer variation for this sanitizer type // Name of the sanitizer variation for this sanitizer type
func (t SanitizerType) variationName() string { func (t SanitizerType) variationName() string {
switch t { switch t {
@@ -133,6 +144,18 @@ func (t SanitizerType) name() string {
} }
} }
func (t SanitizerType) registerMutators(ctx android.RegisterMutatorsContext) {
switch t {
case Asan, Hwasan, Fuzzer, scs, tsan, cfi:
ctx.TopDown(t.variationName()+"_deps", sanitizerDepsMutator(t))
ctx.BottomUp(t.variationName(), sanitizerMutator(t))
case memtag_heap, intOverflow:
// do nothing
default:
panic(fmt.Errorf("unknown SanitizerType %d", t))
}
}
func (*Module) SanitizerSupported(t SanitizerType) bool { func (*Module) SanitizerSupported(t SanitizerType) bool {
switch t { switch t {
case Asan: case Asan:
@@ -160,24 +183,46 @@ func (t SanitizerType) incompatibleWithCfi() bool {
} }
type SanitizeUserProps struct { type SanitizeUserProps struct {
// Prevent use of any sanitizers on this module
Never *bool `android:"arch_variant"` Never *bool `android:"arch_variant"`
// main sanitizers // ASan (Address sanitizer), incompatible with static binaries.
Address *bool `android:"arch_variant"` // Always runs in a diagnostic mode.
Thread *bool `android:"arch_variant"` // Use of address sanitizer disables cfi sanitizer.
// Hwaddress sanitizer takes precedence over this sanitizer.
Address *bool `android:"arch_variant"`
// TSan (Thread sanitizer), incompatible with static binaries and 32 bit architectures.
// Always runs in a diagnostic mode.
// Use of thread sanitizer disables cfi and scudo sanitizers.
// Hwaddress sanitizer takes precedence over this sanitizer.
Thread *bool `android:"arch_variant"`
// HWASan (Hardware Address sanitizer).
// Use of hwasan sanitizer disables cfi, address, thread, and scudo sanitizers.
Hwaddress *bool `android:"arch_variant"` Hwaddress *bool `android:"arch_variant"`
// local sanitizers // Undefined behavior sanitizer
Undefined *bool `android:"arch_variant"` All_undefined *bool `android:"arch_variant"`
All_undefined *bool `android:"arch_variant"` // Subset of undefined behavior sanitizer
Misc_undefined []string `android:"arch_variant"` Undefined *bool `android:"arch_variant"`
Fuzzer *bool `android:"arch_variant"` // List of specific undefined behavior sanitizers to enable
Safestack *bool `android:"arch_variant"` Misc_undefined []string `android:"arch_variant"`
Cfi *bool `android:"arch_variant"` // Fuzzer, incompatible with static binaries.
Integer_overflow *bool `android:"arch_variant"` Fuzzer *bool `android:"arch_variant"`
Scudo *bool `android:"arch_variant"` // safe-stack sanitizer, incompatible with 32-bit architectures.
Scs *bool `android:"arch_variant"` Safestack *bool `android:"arch_variant"`
Memtag_heap *bool `android:"arch_variant"` // cfi sanitizer, incompatible with asan, hwasan, fuzzer, or Darwin
Cfi *bool `android:"arch_variant"`
// signed/unsigned integer overflow sanitizer, incompatible with Darwin.
Integer_overflow *bool `android:"arch_variant"`
// scudo sanitizer, incompatible with asan, hwasan, tsan
// This should not be used in Android 11+ : https://source.android.com/devices/tech/debug/scudo
// deprecated
Scudo *bool `android:"arch_variant"`
// shadow-call-stack sanitizer, only available on arm64
Scs *bool `android:"arch_variant"`
// Memory-tagging, only available on arm64
// if diag.memtag unset or false, enables async memory tagging
Memtag_heap *bool `android:"arch_variant"`
// A modifier for ASAN and HWASAN for write only instrumentation // A modifier for ASAN and HWASAN for write only instrumentation
Writeonly *bool `android:"arch_variant"` Writeonly *bool `android:"arch_variant"`
@@ -186,12 +231,22 @@ type SanitizeUserProps struct {
// Replaces abort() on error with a human-readable error message. // Replaces abort() on error with a human-readable error message.
// Address and Thread sanitizers always run in diagnostic mode. // Address and Thread sanitizers always run in diagnostic mode.
Diag struct { Diag struct {
Undefined *bool `android:"arch_variant"` // Undefined behavior sanitizer, diagnostic mode
Cfi *bool `android:"arch_variant"` Undefined *bool `android:"arch_variant"`
Integer_overflow *bool `android:"arch_variant"` // cfi sanitizer, diagnostic mode, incompatible with asan, hwasan, fuzzer, or Darwin
Memtag_heap *bool `android:"arch_variant"` Cfi *bool `android:"arch_variant"`
Misc_undefined []string `android:"arch_variant"` // signed/unsigned integer overflow sanitizer, diagnostic mode, incompatible with Darwin.
No_recover []string `android:"arch_variant"` Integer_overflow *bool `android:"arch_variant"`
// Memory-tagging, only available on arm64
// requires sanitizer.memtag: true
// if set, enables sync memory tagging
Memtag_heap *bool `android:"arch_variant"`
// List of specific undefined behavior sanitizers to enable in diagnostic mode
Misc_undefined []string `android:"arch_variant"`
// List of sanitizers to pass to -fno-sanitize-recover
// results in only the first detected error for these sanitizers being reported and program then
// exits with a non-zero exit code.
No_recover []string `android:"arch_variant"`
} `android:"arch_variant"` } `android:"arch_variant"`
// Sanitizers to run with flag configuration specified // Sanitizers to run with flag configuration specified
@@ -200,7 +255,9 @@ type SanitizeUserProps struct {
Cfi_assembly_support *bool `android:"arch_variant"` Cfi_assembly_support *bool `android:"arch_variant"`
} `android:"arch_variant"` } `android:"arch_variant"`
// value to pass to -fsanitize-recover= // List of sanitizers to pass to -fsanitize-recover
// allows execution to continue for these sanitizers to detect multiple errors rather than only
// the first one
Recover []string Recover []string
// value to pass to -fsanitize-blacklist // value to pass to -fsanitize-blacklist
@@ -208,9 +265,7 @@ type SanitizeUserProps struct {
} }
type SanitizeProperties struct { type SanitizeProperties struct {
// Enable AddressSanitizer, ThreadSanitizer, UndefinedBehaviorSanitizer, and // Sanitizers are not supported for Fuchsia.
// others. Please see SanitizerUserProps in build/soong/cc/sanitize.go for
// details.
Sanitize SanitizeUserProps `android:"arch_variant"` Sanitize SanitizeUserProps `android:"arch_variant"`
SanitizerEnabled bool `blueprint:"mutated"` SanitizerEnabled bool `blueprint:"mutated"`
SanitizeDep bool `blueprint:"mutated"` SanitizeDep bool `blueprint:"mutated"`
@@ -261,9 +316,13 @@ func (sanitize *sanitize) begin(ctx BaseModuleContext) {
} }
// cc_test targets default to SYNC MemTag unless explicitly set to ASYNC (via diag: {memtag_heap}). // cc_test targets default to SYNC MemTag unless explicitly set to ASYNC (via diag: {memtag_heap}).
if ctx.testBinary() && s.Memtag_heap == nil { if ctx.testBinary() {
s.Memtag_heap = proptools.BoolPtr(true) if s.Memtag_heap == nil {
s.Diag.Memtag_heap = proptools.BoolPtr(true) s.Memtag_heap = proptools.BoolPtr(true)
}
if s.Diag.Memtag_heap == nil {
s.Diag.Memtag_heap = proptools.BoolPtr(true)
}
} }
var globalSanitizers []string var globalSanitizers []string

340
cc/sanitize_test.go
View File

@@ -222,11 +222,12 @@ func (t MemtagNoteType) str() string {
case Async: case Async:
return "async" return "async"
default: default:
panic("invalid note type") panic("type_note_invalid")
} }
} }
func checkHasMemtagNote(t *testing.T, m android.TestingModule, expected MemtagNoteType) { func checkHasMemtagNote(t *testing.T, m android.TestingModule, expected MemtagNoteType) {
t.Helper()
note_async := "note_memtag_heap_async" note_async := "note_memtag_heap_async"
note_sync := "note_memtag_heap_sync" note_sync := "note_memtag_heap_sync"
@@ -251,75 +252,86 @@ var prepareForTestWithMemtagHeap = android.GroupFixturePreparers(
android.FixtureModifyMockFS(func(fs android.MockFS) { android.FixtureModifyMockFS(func(fs android.MockFS) {
templateBp := ` templateBp := `
cc_test { cc_test {
name: "%[1]s_test", name: "unset_test_%[1]s",
gtest: false, gtest: false,
} }
cc_test { cc_test {
name: "%[1]s_test_false", name: "no_memtag_test_%[1]s",
gtest: false, gtest: false,
sanitize: { memtag_heap: false }, sanitize: { memtag_heap: false },
} }
cc_test { cc_test {
name: "%[1]s_test_true", name: "set_memtag_test_%[1]s",
gtest: false, gtest: false,
sanitize: { memtag_heap: true }, sanitize: { memtag_heap: true },
} }
cc_test { cc_test {
name: "%[1]s_test_true_nodiag", name: "set_memtag_set_async_test_%[1]s",
gtest: false, gtest: false,
sanitize: { memtag_heap: true, diag: { memtag_heap: false } }, sanitize: { memtag_heap: true, diag: { memtag_heap: false } },
} }
cc_test { cc_test {
name: "%[1]s_test_true_diag", name: "set_memtag_set_sync_test_%[1]s",
gtest: false, gtest: false,
sanitize: { memtag_heap: true, diag: { memtag_heap: true } }, sanitize: { memtag_heap: true, diag: { memtag_heap: true } },
} }
cc_binary { cc_test {
name: "%[1]s_binary", name: "unset_memtag_set_sync_test_%[1]s",
gtest: false,
sanitize: { diag: { memtag_heap: true } },
} }
cc_binary { cc_binary {
name: "%[1]s_binary_false", name: "unset_binary_%[1]s",
}
cc_binary {
name: "no_memtag_binary_%[1]s",
sanitize: { memtag_heap: false }, sanitize: { memtag_heap: false },
} }
cc_binary { cc_binary {
name: "%[1]s_binary_true", name: "set_memtag_binary_%[1]s",
sanitize: { memtag_heap: true }, sanitize: { memtag_heap: true },
} }
cc_binary { cc_binary {
name: "%[1]s_binary_true_nodiag", name: "set_memtag_set_async_binary_%[1]s",
sanitize: { memtag_heap: true, diag: { memtag_heap: false } }, sanitize: { memtag_heap: true, diag: { memtag_heap: false } },
} }
cc_binary { cc_binary {
name: "%[1]s_binary_true_diag", name: "set_memtag_set_sync_binary_%[1]s",
sanitize: { memtag_heap: true, diag: { memtag_heap: true } }, sanitize: { memtag_heap: true, diag: { memtag_heap: true } },
} }
cc_binary {
name: "unset_memtag_set_sync_binary_%[1]s",
sanitize: { diag: { memtag_heap: true } },
}
` `
subdirDefaultBp := fmt.Sprintf(templateBp, "default") subdirNoOverrideBp := fmt.Sprintf(templateBp, "no_override")
subdirExcludeBp := fmt.Sprintf(templateBp, "exclude") subdirOverrideDefaultDisableBp := fmt.Sprintf(templateBp, "override_default_disable")
subdirSyncBp := fmt.Sprintf(templateBp, "sync") subdirSyncBp := fmt.Sprintf(templateBp, "override_default_sync")
subdirAsyncBp := fmt.Sprintf(templateBp, "async") subdirAsyncBp := fmt.Sprintf(templateBp, "override_default_async")
fs.Merge(android.MockFS{ fs.Merge(android.MockFS{
"subdir_default/Android.bp": []byte(subdirDefaultBp), "subdir_no_override/Android.bp": []byte(subdirNoOverrideBp),
"subdir_exclude/Android.bp": []byte(subdirExcludeBp), "subdir_override_default_disable/Android.bp": []byte(subdirOverrideDefaultDisableBp),
"subdir_sync/Android.bp": []byte(subdirSyncBp), "subdir_sync/Android.bp": []byte(subdirSyncBp),
"subdir_async/Android.bp": []byte(subdirAsyncBp), "subdir_async/Android.bp": []byte(subdirAsyncBp),
}) })
}), }),
android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) { android.FixtureModifyProductVariables(func(variables android.FixtureProductVariables) {
variables.MemtagHeapExcludePaths = []string{"subdir_exclude"} variables.MemtagHeapExcludePaths = []string{"subdir_override_default_disable"}
// "subdir_exclude" is covered by both include and exclude paths. Exclude wins. // "subdir_override_default_disable" is covered by both include and override_default_disable paths. override_default_disable wins.
variables.MemtagHeapSyncIncludePaths = []string{"subdir_sync", "subdir_exclude"} variables.MemtagHeapSyncIncludePaths = []string{"subdir_sync", "subdir_override_default_disable"}
variables.MemtagHeapAsyncIncludePaths = []string{"subdir_async", "subdir_exclude"} variables.MemtagHeapAsyncIncludePaths = []string{"subdir_async", "subdir_override_default_disable"}
}), }),
) )
@@ -332,53 +344,67 @@ func TestSanitizeMemtagHeap(t *testing.T) {
).RunTest(t) ).RunTest(t)
ctx := result.TestContext ctx := result.TestContext
checkHasMemtagNote(t, ctx.ModuleForTests("default_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_no_override", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_async", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_sync", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_no_override", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_async", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_sync", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_no_override", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_async", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_disable", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_no_override", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_async", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_disable", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_sync", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_no_override", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_async", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_disable", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_sync", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_true_diag", variant), Sync)
// should sanitize: { diag: { memtag: true } } result in Sync instead of None here?
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_no_override", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_async", variant), Sync)
// should sanitize: { diag: { memtag: true } } result in Sync instead of None here?
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_no_override", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_async", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_sync", variant), Sync)
} }
func TestSanitizeMemtagHeapWithSanitizeDevice(t *testing.T) { func TestSanitizeMemtagHeapWithSanitizeDevice(t *testing.T) {
@@ -393,53 +419,66 @@ func TestSanitizeMemtagHeapWithSanitizeDevice(t *testing.T) {
).RunTest(t) ).RunTest(t)
ctx := result.TestContext ctx := result.TestContext
checkHasMemtagNote(t, ctx.ModuleForTests("default_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_no_override", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_async", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_sync", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_no_override", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_async", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_sync", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_no_override", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_async", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_disable", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_no_override", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_async", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_disable", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_sync", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_no_override", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_async", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_true", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_disable", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_sync", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_async", variant), Sync)
// should sanitize: { diag: { memtag: true } } result in Sync instead of None here?
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_no_override", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_async", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_sync", variant), Sync)
} }
func TestSanitizeMemtagHeapWithSanitizeDeviceDiag(t *testing.T) { func TestSanitizeMemtagHeapWithSanitizeDeviceDiag(t *testing.T) {
@@ -455,51 +494,64 @@ func TestSanitizeMemtagHeapWithSanitizeDeviceDiag(t *testing.T) {
).RunTest(t) ).RunTest(t)
ctx := result.TestContext ctx := result.TestContext
checkHasMemtagNote(t, ctx.ModuleForTests("default_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_no_override", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_async", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_binary_override_default_sync", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_no_override", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_async", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("no_memtag_test_override_default_sync", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("default_binary_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_test_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("exclude_binary_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_no_override", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_async", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_disable", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_binary_override_default_sync", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_no_override", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_async", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_disable", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_async_test_override_default_sync", variant), Async)
checkHasMemtagNote(t, ctx.ModuleForTests("async_binary_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_test_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_false", variant), None) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_true", variant), Sync) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_true_nodiag", variant), Async) checkHasMemtagNote(t, ctx.ModuleForTests("set_memtag_set_sync_test_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("sync_binary_true_diag", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_async", variant), Sync)
// should sanitize: { diag: { memtag: true } } result in Sync instead of None here?
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_memtag_set_sync_test_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_disable", variant), None)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_binary_override_default_sync", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_no_override", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_async", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_disable", variant), Sync)
checkHasMemtagNote(t, ctx.ModuleForTests("unset_test_override_default_sync", variant), Sync)
} }