Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dbb5da87 authored by Jiyong Park's avatar Jiyong Park Committed by android-build-merger
Browse files

Merge "Fix sanitizer dep" am: e49256e5 

am: 72969547

Change-Id: Iede7979035dffe4ab0cc0b84b65d7d82d512bd39
parents 23937cba 72969547

android/mutator.go

+5 −0
Original line number Diff line number Diff line
@@ -143,6 +143,7 @@ type BottomUpMutatorContext interface { 
	CreateVariations(...string) []blueprint.Module

	CreateLocalVariations(...string) []blueprint.Module

	SetDependencyVariation(string)

	SetDefaultDependencyVariation(*string)

	AddVariationDependencies([]blueprint.Variation, blueprint.DependencyTag, ...string)

	AddFarVariationDependencies([]blueprint.Variation, blueprint.DependencyTag, ...string)

	AddInterVariantDependency(tag blueprint.DependencyTag, from, to blueprint.Module)
@@ -292,6 +293,10 @@ func (b *bottomUpMutatorContext) SetDependencyVariation(variation string) { 
	b.bp.SetDependencyVariation(variation)

}



func (b *bottomUpMutatorContext) SetDefaultDependencyVariation(variation *string) {

	b.bp.SetDefaultDependencyVariation(variation)

}



func (b *bottomUpMutatorContext) AddVariationDependencies(variations []blueprint.Variation, tag blueprint.DependencyTag,

	names ...string) {

cc/cc.go

+16 −0
Original line number Diff line number Diff line
@@ -56,6 +56,8 @@ func init() { 
		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()
@@ -255,6 +257,7 @@ type VendorProperties struct { 
type ModuleContextIntf interface {

	static() bool

	staticBinary() bool

	header() bool

	toolchain() config.Toolchain

	useSdk() bool

	sdkVersion() string
@@ -715,6 +718,10 @@ func (ctx *moduleContextImpl) staticBinary() bool { 
	return ctx.mod.staticBinary()

}



func (ctx *moduleContextImpl) header() bool {

	return ctx.mod.header()

}



func (ctx *moduleContextImpl) useSdk() bool {

	if ctx.ctx.Device() && !ctx.useVndk() && !ctx.inRecovery() && !ctx.ctx.Fuchsia() {

		return String(ctx.mod.Properties.Sdk_version) != ""
@@ -2023,6 +2030,15 @@ func (c *Module) staticBinary() bool { 
	return false

}



func (c *Module) header() bool {

	if h, ok := c.linker.(interface {

		header() bool

	}); ok {

		return h.header()

	}

	return false

}



func (c *Module) getMakeLinkType(actx android.ModuleContext) string {

	name := actx.ModuleName()

	if c.useVndk() {

cc/llndk_library.go

+1 −1
Original line number Diff line number Diff line
@@ -232,7 +232,7 @@ func llndkHeadersFactory() android.Module { 
		&library.MutatedProperties,

		&library.flagExporter.Properties)



	android.InitAndroidArchModule(module, android.DeviceSupported, android.MultilibBoth)

	module.Init()



	return module

}

cc/sanitize.go

+74 −101
Original line number Diff line number Diff line
@@ -125,6 +125,10 @@ func (t sanitizerType) name() string { 
	}

}



func (t sanitizerType) incompatibleWithCfi() bool {

	return t == asan || t == fuzzer || t == hwasan

}



type SanitizeProperties struct {

	// enable AddressSanitizer, ThreadSanitizer, or UndefinedBehaviorSanitizer

	Sanitize struct {
@@ -557,18 +561,20 @@ func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags) Flags { 
}



func (sanitize *sanitize) AndroidMk(ctx AndroidMkContext, ret *android.AndroidMkData) {

	// Add a suffix for CFI-enabled static libraries to allow surfacing both to make without a

	// name conflict.

	if ret.Class == "STATIC_LIBRARIES" && Bool(sanitize.Properties.Sanitize.Cfi) {

	// Add a suffix for cfi/hwasan/scs-enabled static/header libraries to allow surfacing

	// both the sanitized and non-sanitized variants to make without a name conflict.

	if ret.Class == "STATIC_LIBRARIES" || ret.Class == "HEADER_LIBRARIES" {

		if Bool(sanitize.Properties.Sanitize.Cfi) {

			ret.SubName += ".cfi"

		}

	if ret.Class == "STATIC_LIBRARIES" && Bool(sanitize.Properties.Sanitize.Hwaddress) {

		if Bool(sanitize.Properties.Sanitize.Hwaddress) {

			ret.SubName += ".hwasan"

		}

	if ret.Class == "STATIC_LIBRARIES" && Bool(sanitize.Properties.Sanitize.Scs) {

		if Bool(sanitize.Properties.Sanitize.Scs) {

			ret.SubName += ".scs"

		}

	}

}



func (sanitize *sanitize) inSanitizerDir() bool {

	return sanitize.Properties.InSanitizerDir
@@ -871,7 +877,7 @@ func sanitizerRuntimeMutator(mctx android.BottomUpMutatorContext) { 
					{Mutator: "image", Variation: c.imageVariation()},

					{Mutator: "arch", Variation: mctx.Target().String()},

				}, staticDepTag, runtimeLibrary)

			} else if !c.static() {

			} else if !c.static() && !c.header() {

				// dynamic executable and shared libs get shared runtime libs

				mctx.AddFarVariationDependencies([]blueprint.Variation{

					{Mutator: "link", Variation: "shared"},
@@ -900,23 +906,37 @@ func sanitizerMutator(t sanitizerType) func(android.BottomUpMutatorContext) { 
				modules := mctx.CreateVariations(t.variationName())

				modules[0].(*Module).sanitize.SetSanitizer(t, true)

			} else if c.sanitize.isSanitizerEnabled(t) || c.sanitize.Properties.SanitizeDep {

				// Save original sanitizer status before we assign values to variant

				// 0 as that overwrites the original.

				isSanitizerEnabled := c.sanitize.isSanitizerEnabled(t)



				if mctx.Device() && t.incompatibleWithCfi() {

					// TODO: Make sure that cfi mutator runs "after" any of the sanitizers that

					// are incompatible with cfi

					c.sanitize.SetSanitizer(cfi, false)

				}

				if c.static() || c.header() || t == asan || t == fuzzer {

					// Static and header libs are split into non-sanitized and sanitized variants.

					// Shared libs are not split. However, for asan and fuzzer, we split even for shared

					// libs because a library sanitized for asan/fuzzer can't be linked from a library

					// that isn't sanitized for asan/fuzzer.

					//

					// Note for defaultVariation: since we don't split for shared libs but for static/header

					// libs, it is possible for the sanitized variant of a static/header lib to depend

					// on non-sanitized variant of a shared lib. Such unfulfilled variation causes an

					// error when the module is split. defaultVariation is the name of the variation that

					// will be used when such a dangling dependency occurs during the split of the current

					// module. By setting it to the name of the sanitized variation, the dangling dependency

					// is redirected to the sanitized variant of the dependent module.

					defaultVariation := t.variationName()

					mctx.SetDefaultDependencyVariation(&defaultVariation)

					modules := mctx.CreateVariations("", t.variationName())

					modules[0].(*Module).sanitize.SetSanitizer(t, false)

					modules[1].(*Module).sanitize.SetSanitizer(t, true)



					modules[0].(*Module).sanitize.Properties.SanitizeDep = false

					modules[1].(*Module).sanitize.Properties.SanitizeDep = false



				// We don't need both variants active for anything but CFI-enabled

				// target static libraries, so suppress the appropriate variant in

				// all other cases.

				if t == cfi {

					if c.static() {

						if !mctx.Device() {

					// For cfi/scs/hwasan, we can export both sanitized and un-sanitized variants

					// to Make, because the sanitized version has a different suffix in name.

					// For other types of sanitizers, suppress the variation that is disabled.

					if t != cfi && t != scs && t != hwasan {

						if isSanitizerEnabled {

							modules[0].(*Module).Properties.PreventInstall = true

							modules[0].(*Module).Properties.HideFromMake = true
@@ -924,84 +944,31 @@ func sanitizerMutator(t sanitizerType) func(android.BottomUpMutatorContext) { 
							modules[1].(*Module).Properties.PreventInstall = true

							modules[1].(*Module).Properties.HideFromMake = true

						}

						} else {

							cfiStaticLibs := cfiStaticLibs(mctx.Config())



							cfiStaticLibsMutex.Lock()

							*cfiStaticLibs = append(*cfiStaticLibs, c.Name())

							cfiStaticLibsMutex.Unlock()

						}

					} else {

						modules[0].(*Module).Properties.PreventInstall = true

						modules[0].(*Module).Properties.HideFromMake = true

					}

				} else if t == asan {

					if mctx.Device() {

						// CFI and ASAN are currently mutually exclusive so disable

						// CFI if this is an ASAN variant.

						modules[1].(*Module).sanitize.Properties.InSanitizerDir = true

						modules[1].(*Module).sanitize.SetSanitizer(cfi, false)

					}

					if isSanitizerEnabled {

						modules[0].(*Module).Properties.PreventInstall = true

						modules[0].(*Module).Properties.HideFromMake = true

					} else {

						modules[1].(*Module).Properties.PreventInstall = true

						modules[1].(*Module).Properties.HideFromMake = true

					}

				} else if t == scs {

					// We don't currently link any static libraries built with make into

					// libraries built with SCS, so we don't need logic for propagating

					// SCSness of dependencies into make.

					if !c.static() {

						if isSanitizerEnabled {

							modules[0].(*Module).Properties.PreventInstall = true

							modules[0].(*Module).Properties.HideFromMake = true

						} else {

							modules[1].(*Module).Properties.PreventInstall = true

							modules[1].(*Module).Properties.HideFromMake = true

						}

					}

				} else if t == fuzzer {

					// TODO(b/131771163): CFI and fuzzer support are mutually incompatible

					// as CFI pulls in LTO.

					if mctx.Device() {

						modules[1].(*Module).sanitize.SetSanitizer(cfi, false)

					}

					if isSanitizerEnabled {

						modules[0].(*Module).Properties.PreventInstall = true

						modules[0].(*Module).Properties.HideFromMake = true

					} else {

						modules[1].(*Module).Properties.PreventInstall = true

						modules[1].(*Module).Properties.HideFromMake = true

					}

				} else if t == hwasan {

					if mctx.Device() {

						// CFI and HWASAN are currently mutually exclusive so disable

						// CFI if this is an HWASAN variant.

						modules[1].(*Module).sanitize.SetSanitizer(cfi, false)

					}



					// Export the static lib name to make

					if c.static() {

						if t == cfi {

							appendStringSync(c.Name(), cfiStaticLibs(mctx.Config()), &cfiStaticLibsMutex)

						} else if t == hwasan {

							if c.useVndk() {

							hwasanVendorStaticLibs := hwasanVendorStaticLibs(mctx.Config())

							hwasanStaticLibsMutex.Lock()

							*hwasanVendorStaticLibs = append(*hwasanVendorStaticLibs, c.Name())

							hwasanStaticLibsMutex.Unlock()

								appendStringSync(c.Name(), hwasanVendorStaticLibs(mctx.Config()),

									&hwasanStaticLibsMutex)

							} else {

							hwasanStaticLibs := hwasanStaticLibs(mctx.Config())

							hwasanStaticLibsMutex.Lock()

							*hwasanStaticLibs = append(*hwasanStaticLibs, c.Name())

							hwasanStaticLibsMutex.Unlock()

								appendStringSync(c.Name(), hwasanStaticLibs(mctx.Config()),

									&hwasanStaticLibsMutex)

							}

						}

					} else {

						if isSanitizerEnabled {

							modules[0].(*Module).Properties.PreventInstall = true

							modules[0].(*Module).Properties.HideFromMake = true

						} else {

							modules[1].(*Module).Properties.PreventInstall = true

							modules[1].(*Module).Properties.HideFromMake = true

					}

				} else {

					// Shared libs are not split. Only the sanitized variant is created.

					modules := mctx.CreateVariations(t.variationName())

					modules[0].(*Module).sanitize.SetSanitizer(t, true)

					modules[0].(*Module).sanitize.Properties.SanitizeDep = false



					// locate the asan libraries under /data/asan

					if mctx.Device() && t == asan && isSanitizerEnabled {

						modules[0].(*Module).sanitize.Properties.InSanitizerDir = true

					}

				}

			}
@@ -1037,6 +1004,12 @@ func hwasanVendorStaticLibs(config android.Config) *[]string { 
	}).(*[]string)

}



func appendStringSync(item string, list *[]string, mutex *sync.Mutex) {

	mutex.Lock()

	*list = append(*list, item)

	mutex.Unlock()

}



func enableMinimalRuntime(sanitize *sanitize) bool {

	if !Bool(sanitize.Properties.Sanitize.Address) &&

		!Bool(sanitize.Properties.Sanitize.Hwaddress) &&