Revert "[soong] Add memtag-stack sanitizer, switch to linker-gen..."
Revert submission 2096883-memtag-stack
Reason for revert: b/244454542
Reverted Changes:
I7fee03d90:memtag_stack tests.
I52d2318c8:[soong] Add memtag-stack sanitizer, switch to link...
Change-Id: I3967151d98514fa07f66804aa8ff403df3962fa3
diff --git a/cc/sanitize.go b/cc/sanitize.go
index 8cda021..86472a2 100644
--- a/cc/sanitize.go
+++ b/cc/sanitize.go
@@ -77,7 +77,6 @@
"-fno-sanitize-recover=integer,undefined"}
hwasanGlobalOptions = []string{"heap_history_size=1023", "stack_history_size=512",
"export_memory_stats=0", "max_malloc_fill_size=4096", "malloc_fill_byte=0"}
- memtagStackCommonFlags = []string{"-march=armv8-a+memtag"}
)
type SanitizerType int
@@ -90,7 +89,6 @@
scs
Fuzzer
Memtag_heap
- Memtag_stack
cfi // cfi is last to prevent it running before incompatible mutators
)
@@ -102,7 +100,6 @@
scs,
Fuzzer,
Memtag_heap,
- Memtag_stack,
cfi, // cfi is last to prevent it running before incompatible mutators
}
@@ -123,8 +120,6 @@
return "scs"
case Memtag_heap:
return "memtag_heap"
- case Memtag_stack:
- return "memtag_stack"
case Fuzzer:
return "fuzzer"
default:
@@ -141,8 +136,6 @@
return "hwaddress"
case Memtag_heap:
return "memtag_heap"
- case Memtag_stack:
- return "memtag_stack"
case tsan:
return "thread"
case intOverflow:
@@ -164,7 +157,7 @@
sanitizer := &sanitizerSplitMutator{t}
ctx.TopDown(t.variationName()+"_markapexes", sanitizer.markSanitizableApexesMutator)
ctx.Transition(t.variationName(), sanitizer)
- case Memtag_heap, Memtag_stack, intOverflow:
+ case Memtag_heap, intOverflow:
// do nothing
default:
panic(fmt.Errorf("unknown SanitizerType %d", t))
@@ -189,8 +182,6 @@
return true
case Memtag_heap:
return true
- case Memtag_stack:
- return true
default:
return false
}
@@ -241,10 +232,7 @@
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"`
- // Memory-tagging stack instrumentation, only available on arm64
- // Adds instrumentation to detect stack buffer overflows and use-after-scope using MTE.
- Memtag_stack *bool `android:"arch_variant"`
+ Memtag_heap *bool `android:"arch_variant"`
// A modifier for ASAN and HWASAN for write only instrumentation
Writeonly *bool `android:"arch_variant"`
@@ -330,7 +318,7 @@
return
}
- // cc_test targets default to SYNC MemTag unless explicitly set to ASYNC (via diag: {memtag_heap: false}).
+ // cc_test targets default to SYNC MemTag unless explicitly set to ASYNC (via diag: {memtag_heap}).
if ctx.testBinary() {
if s.Memtag_heap == nil {
s.Memtag_heap = proptools.BoolPtr(true)
@@ -416,10 +404,6 @@
}
}
- if found, globalSanitizers = removeFromList("memtag_stack", globalSanitizers); found && s.Memtag_stack == nil {
- s.Memtag_stack = proptools.BoolPtr(true)
- }
-
if len(globalSanitizers) > 0 {
ctx.ModuleErrorf("unknown global sanitizer option %s", globalSanitizers[0])
}
@@ -488,16 +472,12 @@
// Memtag_heap is only implemented on AArch64.
if ctx.Arch().ArchType != android.Arm64 || !ctx.toolchain().Bionic() {
s.Memtag_heap = nil
- s.Memtag_stack = nil
}
// Also disable CFI if ASAN is enabled.
if Bool(s.Address) || Bool(s.Hwaddress) {
s.Cfi = nil
s.Diag.Cfi = nil
- // HWASAN and ASAN win against MTE.
- s.Memtag_heap = nil
- s.Memtag_stack = nil
}
// Disable sanitizers that depend on the UBSan runtime for windows/darwin builds.
@@ -554,7 +534,7 @@
if ctx.Os() != android.Windows && (Bool(s.All_undefined) || Bool(s.Undefined) || Bool(s.Address) || Bool(s.Thread) ||
Bool(s.Fuzzer) || Bool(s.Safestack) || Bool(s.Cfi) || Bool(s.Integer_overflow) || len(s.Misc_undefined) > 0 ||
- Bool(s.Scudo) || Bool(s.Hwaddress) || Bool(s.Scs) || Bool(s.Memtag_heap) || Bool(s.Memtag_stack)) {
+ Bool(s.Scudo) || Bool(s.Hwaddress) || Bool(s.Scs) || Bool(s.Memtag_heap)) {
sanitize.Properties.SanitizerEnabled = true
}
@@ -711,20 +691,6 @@
}
}
- if Bool(sanitize.Properties.Sanitize.Memtag_stack) {
- flags.Local.CFlags = append(flags.Local.CFlags, memtagStackCommonFlags...)
- flags.Local.AsFlags = append(flags.Local.AsFlags, memtagStackCommonFlags...)
- flags.Local.LdFlags = append(flags.Local.LdFlags, memtagStackCommonFlags...)
- }
-
- if (Bool(sanitize.Properties.Sanitize.Memtag_heap) || Bool(sanitize.Properties.Sanitize.Memtag_stack)) && ctx.binary() {
- if Bool(sanitize.Properties.Sanitize.Diag.Memtag_heap) {
- flags.Local.LdFlags = append(flags.Local.LdFlags, "-fsanitize-memtag-mode=sync")
- } else {
- flags.Local.LdFlags = append(flags.Local.LdFlags, "-fsanitize-memtag-mode=async")
- }
- }
-
if Bool(sanitize.Properties.Sanitize.Integer_overflow) {
flags.Local.CFlags = append(flags.Local.CFlags, intOverflowCflags...)
}
@@ -838,8 +804,6 @@
return sanitize.Properties.Sanitize.Scs
case Memtag_heap:
return sanitize.Properties.Sanitize.Memtag_heap
- case Memtag_stack:
- return sanitize.Properties.Sanitize.Memtag_stack
case Fuzzer:
return sanitize.Properties.Sanitize.Fuzzer
default:
@@ -855,7 +819,6 @@
!sanitize.isSanitizerEnabled(cfi) &&
!sanitize.isSanitizerEnabled(scs) &&
!sanitize.isSanitizerEnabled(Memtag_heap) &&
- !sanitize.isSanitizerEnabled(Memtag_stack) &&
!sanitize.isSanitizerEnabled(Fuzzer)
}
@@ -887,8 +850,6 @@
sanitize.Properties.Sanitize.Scs = bPtr
case Memtag_heap:
sanitize.Properties.Sanitize.Memtag_heap = bPtr
- case Memtag_stack:
- sanitize.Properties.Sanitize.Memtag_stack = bPtr
case Fuzzer:
sanitize.Properties.Sanitize.Fuzzer = bPtr
default:
@@ -1350,11 +1311,23 @@
}
if Bool(c.sanitize.Properties.Sanitize.Memtag_heap) && c.Binary() {
- sanitizers = append(sanitizers, "memtag-heap")
- }
-
- if Bool(c.sanitize.Properties.Sanitize.Memtag_stack) {
- sanitizers = append(sanitizers, "memtag-stack")
+ noteDep := "note_memtag_heap_async"
+ if Bool(c.sanitize.Properties.Sanitize.Diag.Memtag_heap) {
+ noteDep = "note_memtag_heap_sync"
+ }
+ // If we're using snapshots, redirect to snapshot whenever possible
+ // TODO(b/178470649): clean manual snapshot redirections
+ snapshot := mctx.Provider(SnapshotInfoProvider).(SnapshotInfo)
+ if lib, ok := snapshot.StaticLibs[noteDep]; ok {
+ noteDep = lib
+ }
+ depTag := StaticDepTag(true)
+ variations := append(mctx.Target().Variations(),
+ blueprint.Variation{Mutator: "link", Variation: "static"})
+ if c.Device() {
+ variations = append(variations, c.ImageVariation())
+ }
+ mctx.AddFarVariationDependencies(variations, depTag, noteDep)
}
if Bool(c.sanitize.Properties.Sanitize.Fuzzer) {
diff --git a/cc/sanitize_test.go b/cc/sanitize_test.go
index 48ac650..5d7e7d8 100644
--- a/cc/sanitize_test.go
+++ b/cc/sanitize_test.go
@@ -344,13 +344,19 @@
func checkHasMemtagNote(t *testing.T, m android.TestingModule, expected MemtagNoteType) {
t.Helper()
+ note_async := "note_memtag_heap_async"
+ note_sync := "note_memtag_heap_sync"
found := None
- ldFlags := m.Rule("ld").Args["ldFlags"]
- if strings.Contains(ldFlags, "-fsanitize-memtag-mode=async") {
- found = Async
- } else if strings.Contains(ldFlags, "-fsanitize-memtag-mode=sync") {
- found = Sync
+ implicits := m.Rule("ld").Implicits
+ for _, lib := range implicits {
+ if strings.Contains(lib.Rel(), note_async) {
+ found = Async
+ break
+ } else if strings.Contains(lib.Rel(), note_sync) {
+ found = Sync
+ break
+ }
}
if found != expected {