123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460 |
- // Copyright 2020 The Android Open Source Project
- //
- // Licensed under the Apache License, Version 2.0 (the "License");
- // you may not use this file except in compliance with the License.
- // You may obtain a copy of the License at
- //
- // http://www.apache.org/licenses/LICENSE-2.0
- //
- // Unless required by applicable law or agreed to in writing, software
- // distributed under the License is distributed on an "AS IS" BASIS,
- // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- // See the License for the specific language governing permissions and
- // limitations under the License.
- package rust
- import (
- "fmt"
- "strings"
- "github.com/google/blueprint"
- "github.com/google/blueprint/proptools"
- "android/soong/android"
- "android/soong/cc"
- "android/soong/rust/config"
- )
- // TODO: When Rust has sanitizer-parity with CC, deduplicate this struct
- type SanitizeProperties struct {
- // enable AddressSanitizer, HWAddressSanitizer, and others.
- Sanitize struct {
- Address *bool `android:"arch_variant"`
- Hwaddress *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"`
- Fuzzer *bool `android:"arch_variant"`
- Never *bool `android:"arch_variant"`
- // Sanitizers to run in the diagnostic mode (as opposed to the release mode).
- // Replaces abort() on error with a human-readable error message.
- // Address and Thread sanitizers always run in diagnostic mode.
- Diag struct {
- // Memory-tagging, only available on arm64
- // requires sanitizer.memtag: true
- // if set, enables sync memory tagging
- Memtag_heap *bool `android:"arch_variant"`
- }
- }
- SanitizerEnabled bool `blueprint:"mutated"`
- // Used when we need to place libraries in their own directory, such as ASAN.
- InSanitizerDir bool `blueprint:"mutated"`
- }
- var fuzzerFlags = []string{
- "-C passes='sancov-module'",
- "--cfg fuzzing",
- "-C llvm-args=-sanitizer-coverage-level=3",
- "-C llvm-args=-sanitizer-coverage-trace-compares",
- "-C llvm-args=-sanitizer-coverage-inline-8bit-counters",
- "-C llvm-args=-sanitizer-coverage-pc-table",
- // See https://github.com/rust-fuzz/cargo-fuzz/pull/193
- "-C link-dead-code",
- // Sancov breaks with lto
- // TODO: Remove when https://bugs.llvm.org/show_bug.cgi?id=41734 is resolved and sancov-module works with LTO
- "-C lto=no",
- }
- var asanFlags = []string{
- "-Z sanitizer=address",
- }
- // See cc/sanitize.go's hwasanGlobalOptions for global hwasan options.
- var hwasanFlags = []string{
- "-Z sanitizer=hwaddress",
- "-C target-feature=+tagged-globals",
- // Flags from cc/sanitize.go hwasanFlags
- "-C llvm-args=--aarch64-enable-global-isel-at-O=-1",
- "-C llvm-args=-fast-isel=false",
- "-C llvm-args=-instcombine-lower-dbg-declare=0",
- // Additional flags for HWASAN-ified Rust/C interop
- "-C llvm-args=--hwasan-with-ifunc",
- }
- func boolPtr(v bool) *bool {
- if v {
- return &v
- } else {
- return nil
- }
- }
- func init() {
- }
- func (sanitize *sanitize) props() []interface{} {
- return []interface{}{&sanitize.Properties}
- }
- func (sanitize *sanitize) begin(ctx BaseModuleContext) {
- s := &sanitize.Properties.Sanitize
- // Never always wins.
- if Bool(s.Never) {
- return
- }
- // rust_test targets default to SYNC MemTag unless explicitly set to ASYNC (via diag: {Memtag_heap}).
- if binary, ok := ctx.RustModule().compiler.(binaryInterface); ok && binary.testBinary() {
- if s.Memtag_heap == nil {
- s.Memtag_heap = proptools.BoolPtr(true)
- }
- if s.Diag.Memtag_heap == nil {
- s.Diag.Memtag_heap = proptools.BoolPtr(true)
- }
- }
- var globalSanitizers []string
- var globalSanitizersDiag []string
- if ctx.Host() {
- if !ctx.Windows() {
- globalSanitizers = ctx.Config().SanitizeHost()
- }
- } else {
- arches := ctx.Config().SanitizeDeviceArch()
- if len(arches) == 0 || android.InList(ctx.Arch().ArchType.Name, arches) {
- globalSanitizers = ctx.Config().SanitizeDevice()
- globalSanitizersDiag = ctx.Config().SanitizeDeviceDiag()
- }
- }
- if len(globalSanitizers) > 0 {
- var found bool
- // Global Sanitizers
- if found, globalSanitizers = android.RemoveFromList("hwaddress", globalSanitizers); found && s.Hwaddress == nil {
- // TODO(b/204776996): HWASan for static Rust binaries isn't supported yet.
- if !ctx.RustModule().StaticExecutable() {
- s.Hwaddress = proptools.BoolPtr(true)
- }
- }
- if found, globalSanitizers = android.RemoveFromList("memtag_heap", globalSanitizers); found && s.Memtag_heap == nil {
- if !ctx.Config().MemtagHeapDisabledForPath(ctx.ModuleDir()) {
- s.Memtag_heap = proptools.BoolPtr(true)
- }
- }
- if found, globalSanitizers = android.RemoveFromList("address", globalSanitizers); found && s.Address == nil {
- s.Address = proptools.BoolPtr(true)
- }
- if found, globalSanitizers = android.RemoveFromList("fuzzer", globalSanitizers); found && s.Fuzzer == nil {
- // TODO(b/204776996): HWASan for static Rust binaries isn't supported yet, and fuzzer enables HWAsan
- if !ctx.RustModule().StaticExecutable() {
- s.Fuzzer = proptools.BoolPtr(true)
- }
- }
- // Global Diag Sanitizers
- if found, globalSanitizersDiag = android.RemoveFromList("memtag_heap", globalSanitizersDiag); found &&
- s.Diag.Memtag_heap == nil && Bool(s.Memtag_heap) {
- s.Diag.Memtag_heap = proptools.BoolPtr(true)
- }
- }
- // Enable Memtag for all components in the include paths (for Aarch64 only)
- if ctx.Arch().ArchType == android.Arm64 && ctx.Os().Bionic() {
- if ctx.Config().MemtagHeapSyncEnabledForPath(ctx.ModuleDir()) {
- if s.Memtag_heap == nil {
- s.Memtag_heap = proptools.BoolPtr(true)
- }
- if s.Diag.Memtag_heap == nil {
- s.Diag.Memtag_heap = proptools.BoolPtr(true)
- }
- } else if ctx.Config().MemtagHeapAsyncEnabledForPath(ctx.ModuleDir()) {
- if s.Memtag_heap == nil {
- s.Memtag_heap = proptools.BoolPtr(true)
- }
- }
- }
- // HWASan requires AArch64 hardware feature (top-byte-ignore).
- if ctx.Arch().ArchType != android.Arm64 || !ctx.Os().Bionic() {
- s.Hwaddress = nil
- }
- // HWASan ramdisk (which is built from recovery) goes over some bootloader limit.
- // Keep libc instrumented so that ramdisk / vendor_ramdisk / recovery can run hwasan-instrumented code if necessary.
- if (ctx.RustModule().InRamdisk() || ctx.RustModule().InVendorRamdisk() || ctx.RustModule().InRecovery()) && !strings.HasPrefix(ctx.ModuleDir(), "bionic/libc") {
- s.Hwaddress = nil
- }
- if Bool(s.Hwaddress) {
- s.Address = nil
- }
- // Memtag_heap is only implemented on AArch64.
- if ctx.Arch().ArchType != android.Arm64 || !ctx.Os().Bionic() {
- s.Memtag_heap = 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)) {
- sanitize.Properties.SanitizerEnabled = true
- }
- }
- type sanitize struct {
- Properties SanitizeProperties
- }
- func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags, deps PathDeps) (Flags, PathDeps) {
- if !sanitize.Properties.SanitizerEnabled {
- return flags, deps
- }
- if Bool(sanitize.Properties.Sanitize.Fuzzer) {
- flags.RustFlags = append(flags.RustFlags, fuzzerFlags...)
- } else if Bool(sanitize.Properties.Sanitize.Hwaddress) {
- flags.RustFlags = append(flags.RustFlags, hwasanFlags...)
- } else if Bool(sanitize.Properties.Sanitize.Address) {
- flags.RustFlags = append(flags.RustFlags, asanFlags...)
- }
- return flags, deps
- }
- func (sanitize *sanitize) deps(ctx BaseModuleContext, deps Deps) Deps {
- return deps
- }
- func rustSanitizerRuntimeMutator(mctx android.BottomUpMutatorContext) {
- if mod, ok := mctx.Module().(*Module); ok && mod.sanitize != nil {
- if !mod.Enabled() {
- return
- }
- if Bool(mod.sanitize.Properties.Sanitize.Memtag_heap) && mod.Binary() {
- noteDep := "note_memtag_heap_async"
- if Bool(mod.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(cc.SnapshotInfoProvider).(cc.SnapshotInfo)
- if lib, ok := snapshot.StaticLibs[noteDep]; ok {
- noteDep = lib
- }
- depTag := cc.StaticDepTag(true)
- variations := append(mctx.Target().Variations(),
- blueprint.Variation{Mutator: "link", Variation: "static"})
- if mod.Device() {
- variations = append(variations, mod.ImageVariation())
- }
- mctx.AddFarVariationDependencies(variations, depTag, noteDep)
- }
- variations := mctx.Target().Variations()
- var depTag blueprint.DependencyTag
- var deps []string
- if mod.IsSanitizerEnabled(cc.Asan) ||
- (mod.IsSanitizerEnabled(cc.Fuzzer) && (mctx.Arch().ArchType != android.Arm64 || !mctx.Os().Bionic())) {
- variations = append(variations,
- blueprint.Variation{Mutator: "link", Variation: "shared"})
- depTag = cc.SharedDepTag()
- deps = []string{config.LibclangRuntimeLibrary(mod.toolchain(mctx), "asan")}
- } else if mod.IsSanitizerEnabled(cc.Hwasan) ||
- (mod.IsSanitizerEnabled(cc.Fuzzer) && mctx.Arch().ArchType == android.Arm64 && mctx.Os().Bionic()) {
- // TODO(b/204776996): HWASan for static Rust binaries isn't supported yet.
- if binary, ok := mod.compiler.(binaryInterface); ok {
- if binary.staticallyLinked() {
- mctx.ModuleErrorf("HWASan is not supported for static Rust executables yet.")
- }
- }
- // Always link against the shared library -- static binaries will pull in the static
- // library during final link if necessary
- variations = append(variations,
- blueprint.Variation{Mutator: "link", Variation: "shared"})
- depTag = cc.SharedDepTag()
- deps = []string{config.LibclangRuntimeLibrary(mod.toolchain(mctx), "hwasan")}
- }
- if len(deps) > 0 {
- mctx.AddFarVariationDependencies(variations, depTag, deps...)
- }
- }
- }
- func (sanitize *sanitize) SetSanitizer(t cc.SanitizerType, b bool) {
- sanitizerSet := false
- switch t {
- case cc.Fuzzer:
- sanitize.Properties.Sanitize.Fuzzer = boolPtr(b)
- sanitizerSet = true
- case cc.Asan:
- sanitize.Properties.Sanitize.Address = boolPtr(b)
- sanitizerSet = true
- case cc.Hwasan:
- sanitize.Properties.Sanitize.Hwaddress = boolPtr(b)
- sanitizerSet = true
- case cc.Memtag_heap:
- sanitize.Properties.Sanitize.Memtag_heap = boolPtr(b)
- sanitizerSet = true
- default:
- panic(fmt.Errorf("setting unsupported sanitizerType %d", t))
- }
- if b && sanitizerSet {
- sanitize.Properties.SanitizerEnabled = true
- }
- }
- func (m *Module) UbsanRuntimeNeeded() bool {
- return false
- }
- func (m *Module) MinimalRuntimeNeeded() bool {
- return false
- }
- func (m *Module) UbsanRuntimeDep() bool {
- return false
- }
- func (m *Module) MinimalRuntimeDep() bool {
- return false
- }
- // Check if the sanitizer is explicitly disabled (as opposed to nil by
- // virtue of not being set).
- func (sanitize *sanitize) isSanitizerExplicitlyDisabled(t cc.SanitizerType) bool {
- if sanitize == nil {
- return false
- }
- if Bool(sanitize.Properties.Sanitize.Never) {
- return true
- }
- sanitizerVal := sanitize.getSanitizerBoolPtr(t)
- return sanitizerVal != nil && *sanitizerVal == false
- }
- // There isn't an analog of the method above (ie:isSanitizerExplicitlyEnabled)
- // because enabling a sanitizer either directly (via the blueprint) or
- // indirectly (via a mutator) sets the bool ptr to true, and you can't
- // distinguish between the cases. It isn't needed though - both cases can be
- // treated identically.
- func (sanitize *sanitize) isSanitizerEnabled(t cc.SanitizerType) bool {
- if sanitize == nil || !sanitize.Properties.SanitizerEnabled {
- return false
- }
- sanitizerVal := sanitize.getSanitizerBoolPtr(t)
- return sanitizerVal != nil && *sanitizerVal == true
- }
- func (sanitize *sanitize) getSanitizerBoolPtr(t cc.SanitizerType) *bool {
- switch t {
- case cc.Fuzzer:
- return sanitize.Properties.Sanitize.Fuzzer
- case cc.Asan:
- return sanitize.Properties.Sanitize.Address
- case cc.Hwasan:
- return sanitize.Properties.Sanitize.Hwaddress
- case cc.Memtag_heap:
- return sanitize.Properties.Sanitize.Memtag_heap
- default:
- return nil
- }
- }
- func (sanitize *sanitize) AndroidMk(ctx AndroidMkContext, entries *android.AndroidMkEntries) {
- // Add a suffix for hwasan rlib libraries to allow surfacing both the sanitized and
- // non-sanitized variants to make without a name conflict.
- if entries.Class == "RLIB_LIBRARIES" || entries.Class == "STATIC_LIBRARIES" {
- if sanitize.isSanitizerEnabled(cc.Hwasan) {
- entries.SubName += ".hwasan"
- }
- }
- }
- func (mod *Module) SanitizerSupported(t cc.SanitizerType) bool {
- if mod.Host() {
- return false
- }
- switch t {
- case cc.Fuzzer:
- return true
- case cc.Asan:
- return true
- case cc.Hwasan:
- // TODO(b/180495975): HWASan for static Rust binaries isn't supported yet.
- if mod.StaticExecutable() {
- return false
- }
- return true
- case cc.Memtag_heap:
- return true
- default:
- return false
- }
- }
- func (mod *Module) IsSanitizerEnabled(t cc.SanitizerType) bool {
- return mod.sanitize.isSanitizerEnabled(t)
- }
- func (mod *Module) IsSanitizerExplicitlyDisabled(t cc.SanitizerType) bool {
- if mod.Host() {
- return true
- }
- return mod.sanitize.isSanitizerExplicitlyDisabled(t)
- }
- func (mod *Module) SetSanitizer(t cc.SanitizerType, b bool) {
- if !Bool(mod.sanitize.Properties.Sanitize.Never) {
- mod.sanitize.SetSanitizer(t, b)
- }
- }
- func (mod *Module) StaticallyLinked() bool {
- if lib, ok := mod.compiler.(libraryInterface); ok {
- return lib.rlib() || lib.static()
- } else if binary, ok := mod.compiler.(binaryInterface); ok {
- return binary.staticallyLinked()
- }
- return false
- }
- func (mod *Module) SetInSanitizerDir() {
- mod.sanitize.Properties.InSanitizerDir = true
- }
- func (mod *Module) SanitizeNever() bool {
- return Bool(mod.sanitize.Properties.Sanitize.Never)
- }
- var _ cc.PlatformSanitizeable = (*Module)(nil)
- func IsSanitizableDependencyTag(tag blueprint.DependencyTag) bool {
- switch t := tag.(type) {
- case dependencyTag:
- return t.library
- default:
- return cc.IsSanitizableDependencyTag(tag)
- }
- }
- func (m *Module) SanitizableDepTagChecker() cc.SantizableDependencyTagChecker {
- return IsSanitizableDependencyTag
- }
|