tequilaOS/platform_build_soong
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "Revert "rust: Add SCS sanitizer option."" into main

Browse source
This commit is contained in:
Ivan Lozano 2023-07-27 15:08:50 +00:00 committed by Gerrit Code Review
commit 7e377d045e
3 changed files with 13 additions and 36 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
cc/sanitize.go
View file

@ -100,7 +100,7 @@ const (
Hwasan
tsan
intOverflow
Scs
scs
Fuzzer
Memtag_heap
Memtag_stack
@ -113,7 +113,7 @@ var Sanitizers = []SanitizerType{
Hwasan,
tsan,
intOverflow,
Scs,
scs,
Fuzzer,
Memtag_heap,
Memtag_stack,
@ -134,7 +134,7 @@ func (t SanitizerType) variationName() string {
return "intOverflow"
case cfi:
return "cfi"
case Scs:
case scs:
return "scs"
case Memtag_heap:
return "memtag_heap"
@ -168,7 +168,7 @@ func (t SanitizerType) name() string {
return "integer_overflow"
case cfi:
return "cfi"
case Scs:
case scs:
return "shadow-call-stack"
case Fuzzer:
return "fuzzer"
@ -179,7 +179,7 @@ func (t SanitizerType) name() string {
func (t SanitizerType) registerMutators(ctx android.RegisterMutatorsContext) {
switch t {
case cfi, Hwasan, Asan, tsan, Fuzzer, Scs:
case cfi, Hwasan, Asan, tsan, Fuzzer, scs:
sanitizer := &sanitizerSplitMutator{t}
ctx.TopDown(t.variationName()+"_markapexes", sanitizer.markSanitizableApexesMutator)
ctx.Transition(t.variationName(), sanitizer)
@ -216,7 +216,7 @@ func (*Module) SanitizerSupported(t SanitizerType) bool {
return true
case cfi:
return true
case Scs:
case scs:
return true
case Fuzzer:
return true
@ -1022,7 +1022,7 @@ func (s *sanitize) getSanitizerBoolPtr(t SanitizerType) *bool {
return s.Properties.SanitizeMutated.Integer_overflow
case cfi:
return s.Properties.SanitizeMutated.Cfi
case Scs:
case scs:
return s.Properties.SanitizeMutated.Scs
case Memtag_heap:
return s.Properties.SanitizeMutated.Memtag_heap
@ -1043,7 +1043,7 @@ func (sanitize *sanitize) isUnsanitizedVariant() bool {
!sanitize.isSanitizerEnabled(Hwasan) &&
!sanitize.isSanitizerEnabled(tsan) &&
!sanitize.isSanitizerEnabled(cfi) &&
!sanitize.isSanitizerEnabled(Scs) &&
!sanitize.isSanitizerEnabled(scs) &&
!sanitize.isSanitizerEnabled(Memtag_heap) &&
!sanitize.isSanitizerEnabled(Memtag_stack) &&
!sanitize.isSanitizerEnabled(Memtag_globals) &&
@ -1080,7 +1080,7 @@ func (sanitize *sanitize) SetSanitizer(t SanitizerType, b bool) {
sanitize.Properties.SanitizeMutated.Integer_overflow = bPtr
case cfi:
sanitize.Properties.SanitizeMutated.Cfi = bPtr
case Scs:
case scs:
sanitize.Properties.SanitizeMutated.Scs = bPtr
case Memtag_heap:
sanitize.Properties.SanitizeMutated.Memtag_heap = bPtr
@ -1340,7 +1340,7 @@ func (s *sanitizerSplitMutator) Mutate(mctx android.BottomUpMutatorContext, vari
oneMakeVariation := false
if c.StaticallyLinked() || c.Header() {
if s.sanitizer != cfi && s.sanitizer != Scs && s.sanitizer != Hwasan {
if s.sanitizer != cfi && s.sanitizer != scs && s.sanitizer != Hwasan {
// These sanitizers export only one variation to Make. For the rest,
// Make targets can depend on both the sanitized and non-sanitized
// versions.
@ -1350,7 +1350,7 @@ func (s *sanitizerSplitMutator) Mutate(mctx android.BottomUpMutatorContext, vari
// Shared library. These are the sanitizers that do propagate through shared
// library dependencies and therefore can cause multiple variations of a
// shared library to be built.
if s.sanitizer != cfi && s.sanitizer != Hwasan && s.sanitizer != Scs && s.sanitizer != Asan {
if s.sanitizer != cfi && s.sanitizer != Hwasan && s.sanitizer != scs && s.sanitizer != Asan {
oneMakeVariation = true
}
}

2
cc/vendor_snapshot.go
View file

@ -95,7 +95,7 @@ func isSnapshotAware(cfg android.DeviceConfig, m LinkableInterface, inProprietar
if sanitizable.SanitizePropDefined() {
// scs exports both sanitized and unsanitized variants for static and header
// Always use unsanitized variant of it.
if !sanitizable.Shared() && sanitizable.IsSanitizerEnabled(Scs) {
if !sanitizable.Shared() && sanitizable.IsSanitizerEnabled(scs) {
return false
}
// cfi and hwasan also export both variants. But for static, we capture both.

25
rust/sanitize.go
View file

@ -32,7 +32,6 @@ type SanitizeProperties struct {
Sanitize struct {
Address *bool `android:"arch_variant"`
Hwaddress *bool `android:"arch_variant"`
Scs *bool `android:"arch_variant"`
// Memory-tagging, only available on arm64
// if diag.memtag unset or false, enables async memory tagging
@ -76,9 +75,6 @@ var fuzzerFlags = []string{
var asanFlags = []string{
"-Z sanitizer=address",
}
var scsFlags = []string{
"-Z sanitizer=shadow-call-stack",
}
// See cc/sanitize.go's hwasanGlobalOptions for global hwasan options.
var hwasanFlags = []string{
@ -212,14 +208,9 @@ func (sanitize *sanitize) begin(ctx BaseModuleContext) {
s.Memtag_heap = nil
}
// SCS is only implemented on AArch64/riscv64.
if (ctx.Arch().ArchType != android.Arm64 && ctx.Arch().ArchType != android.Riscv64) || !ctx.toolchain().Bionic() {
s.Scs = nil
}
// TODO:(b/178369775)
// For now sanitizing is only supported on devices
if ctx.Os() == android.Android && (Bool(s.Hwaddress) || Bool(s.Address) || Bool(s.Memtag_heap) || Bool(s.Fuzzer) || Bool(s.Scs)) {
if ctx.Os() == android.Android && (Bool(s.Hwaddress) || Bool(s.Address) || Bool(s.Memtag_heap) || Bool(s.Fuzzer)) {
sanitize.Properties.SanitizerEnabled = true
}
}
@ -238,10 +229,7 @@ func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags, deps PathDeps) (
flags.RustFlags = append(flags.RustFlags, hwasanFlags...)
} else if Bool(sanitize.Properties.Sanitize.Address) {
flags.RustFlags = append(flags.RustFlags, asanFlags...)
} else if Bool(sanitize.Properties.Sanitize.Scs) {
flags.RustFlags = append(flags.RustFlags, scsFlags...)
}
return flags, deps
}
@ -323,9 +311,6 @@ func (sanitize *sanitize) SetSanitizer(t cc.SanitizerType, b bool) {
case cc.Memtag_heap:
sanitize.Properties.Sanitize.Memtag_heap = boolPtr(b)
sanitizerSet = true
case cc.Scs:
sanitize.Properties.Sanitize.Scs = boolPtr(b)
sanitizerSet = true
default:
panic(fmt.Errorf("setting unsupported sanitizerType %d", t))
}
@ -387,8 +372,6 @@ func (sanitize *sanitize) getSanitizerBoolPtr(t cc.SanitizerType) *bool {
return sanitize.Properties.Sanitize.Hwaddress
case cc.Memtag_heap:
return sanitize.Properties.Sanitize.Memtag_heap
case cc.Scs:
return sanitize.Properties.Sanitize.Scs
default:
return nil
}
@ -401,10 +384,6 @@ func (sanitize *sanitize) AndroidMk(ctx AndroidMkContext, entries *android.Andro
if sanitize.isSanitizerEnabled(cc.Hwasan) {
entries.SubName += ".hwasan"
}
if sanitize.isSanitizerEnabled(cc.Scs) {
entries.SubName += ".scs"
}
}
}
@ -425,8 +404,6 @@ func (mod *Module) SanitizerSupported(t cc.SanitizerType) bool {
return true
case cc.Memtag_heap:
return true
case cc.Scs:
return true
default:
return false
}