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

Merge "Allow Linux hosts to use ubsan runtime sanitizers."

Browse source
This commit is contained in:
Ivan Lozano 2020-02-11 18:37:17 +00:00 committed by Gerrit Code Review
commit 0dbb324a83
2 changed files with 58 additions and 35 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
cc/config/x86_linux_host.go
View file

@ -234,7 +234,7 @@ func (t *toolchainLinuxX8664) YasmFlags() string {
} }
func (toolchainLinuxX86) LibclangRuntimeLibraryArch() string { func (toolchainLinuxX86) LibclangRuntimeLibraryArch() string {
return "i686" return "i386"
} }
func (toolchainLinuxX8664) LibclangRuntimeLibraryArch() string { func (toolchainLinuxX8664) LibclangRuntimeLibraryArch() string {

91
cc/sanitize.go
View file

@ -334,8 +334,8 @@ func (sanitize *sanitize) begin(ctx BaseModuleContext) {
s.Diag.Cfi = nil s.Diag.Cfi = nil
} }
// Disable sanitizers that depend on the UBSan runtime for host builds. // Disable sanitizers that depend on the UBSan runtime for windows/darwin builds.
if ctx.Host() { if !ctx.Os().Linux() {
s.Cfi = nil s.Cfi = nil
s.Diag.Cfi = nil s.Diag.Cfi = nil
s.Misc_undefined = nil s.Misc_undefined = nil
@ -433,11 +433,18 @@ func toDisableImplicitIntegerChange(flags []string) bool {
func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags) Flags { func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags) Flags {
minimalRuntimeLib := config.UndefinedBehaviorSanitizerMinimalRuntimeLibrary(ctx.toolchain()) + ".a" minimalRuntimeLib := config.UndefinedBehaviorSanitizerMinimalRuntimeLibrary(ctx.toolchain()) + ".a"
minimalRuntimePath := "${config.ClangAsanLibDir}/" + minimalRuntimeLib minimalRuntimePath := "${config.ClangAsanLibDir}/" + minimalRuntimeLib
builtinsRuntimeLib := config.BuiltinsRuntimeLibrary(ctx.toolchain()) + ".a"
builtinsRuntimePath := "${config.ClangAsanLibDir}/" + builtinsRuntimeLib
if ctx.Device() && sanitize.Properties.MinimalRuntimeDep { if sanitize.Properties.MinimalRuntimeDep {
flags.Local.LdFlags = append(flags.Local.LdFlags, flags.Local.LdFlags = append(flags.Local.LdFlags,
minimalRuntimePath, minimalRuntimePath,
"-Wl,--exclude-libs,"+minimalRuntimeLib) "-Wl,--exclude-libs,"+minimalRuntimeLib)
if ctx.Host() {
flags.Local.LdFlags = append(flags.Local.LdFlags,
builtinsRuntimePath,
"-Wl,--exclude-libs,"+builtinsRuntimeLib)
}
} }
if !sanitize.Properties.SanitizerEnabled && !sanitize.Properties.UbsanRuntimeDep { if !sanitize.Properties.SanitizerEnabled && !sanitize.Properties.UbsanRuntimeDep {
return flags return flags
@ -541,11 +548,15 @@ func (sanitize *sanitize) flags(ctx ModuleContext, flags Flags) Flags {
// there will always be undefined symbols in intermediate libraries. // there will always be undefined symbols in intermediate libraries.
_, flags.Global.LdFlags = removeFromList("-Wl,--no-undefined", flags.Global.LdFlags) _, flags.Global.LdFlags = removeFromList("-Wl,--no-undefined", flags.Global.LdFlags)
flags.Local.LdFlags = append(flags.Local.LdFlags, sanitizeArg) flags.Local.LdFlags = append(flags.Local.LdFlags, sanitizeArg)
} else { }
if enableMinimalRuntime(sanitize) {
flags.Local.CFlags = append(flags.Local.CFlags, strings.Join(minimalRuntimeFlags, " ")) if enableMinimalRuntime(sanitize) {
flags.libFlags = append([]string{minimalRuntimePath}, flags.libFlags...) flags.Local.CFlags = append(flags.Local.CFlags, strings.Join(minimalRuntimeFlags, " "))
flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--exclude-libs,"+minimalRuntimeLib) flags.libFlags = append([]string{minimalRuntimePath}, flags.libFlags...)
flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--exclude-libs,"+minimalRuntimeLib)
if !ctx.toolchain().Bionic() {
flags.libFlags = append([]string{builtinsRuntimePath}, flags.libFlags...)
flags.Local.LdFlags = append(flags.Local.LdFlags, "-Wl,--exclude-libs,"+builtinsRuntimeLib)
} }
} }
@ -887,34 +898,46 @@ func sanitizerRuntimeMutator(mctx android.BottomUpMutatorContext) {
runtimeLibrary = config.UndefinedBehaviorSanitizerRuntimeLibrary(toolchain) runtimeLibrary = config.UndefinedBehaviorSanitizerRuntimeLibrary(toolchain)
} }
if mctx.Device() && runtimeLibrary != "" { if runtimeLibrary != "" {
if isLlndkLibrary(runtimeLibrary, mctx.Config()) && !c.static() && c.UseVndk() { // Devices and LinuxBionic use the same libraries.
runtimeLibrary = runtimeLibrary + llndkLibrarySuffix if toolchain.Bionic() {
} if isLlndkLibrary(runtimeLibrary, mctx.Config()) && !c.static() && c.UseVndk() {
runtimeLibrary = runtimeLibrary + llndkLibrarySuffix
}
// Adding dependency to the runtime library. We are using *FarVariation* // Adding dependency to the runtime library. We are using *FarVariation*
// because the runtime libraries themselves are not mutated by sanitizer // because the runtime libraries themselves are not mutated by sanitizer
// mutators and thus don't have sanitizer variants whereas this module // mutators and thus don't have sanitizer variants whereas this module
// has been already mutated. // has been already mutated.
// //
// Note that by adding dependency with {static|shared}DepTag, the lib is // Note that by adding dependency with {static|shared}DepTag, the lib is
// added to libFlags and LOCAL_SHARED_LIBRARIES by cc.Module // added to libFlags and LOCAL_SHARED_LIBRARIES by cc.Module
if c.staticBinary() { if c.staticBinary() {
// static executable gets static runtime libs // static executable gets static runtime libs
mctx.AddFarVariationDependencies(append(mctx.Target().Variations(), []blueprint.Variation{ mctx.AddFarVariationDependencies(append(mctx.Target().Variations(), []blueprint.Variation{
{Mutator: "link", Variation: "static"}, {Mutator: "link", Variation: "static"},
c.ImageVariation(), c.ImageVariation(),
}...), StaticDepTag, append([]string{runtimeLibrary}, extraStaticDeps...)...) }...), StaticDepTag, append([]string{runtimeLibrary}, extraStaticDeps...)...)
} else if !c.static() && !c.header() { } else if !c.static() && !c.header() {
// dynamic executable and shared libs get shared runtime libs // dynamic executable and shared libs get shared runtime libs
mctx.AddFarVariationDependencies(append(mctx.Target().Variations(), []blueprint.Variation{ mctx.AddFarVariationDependencies(append(mctx.Target().Variations(), []blueprint.Variation{
{Mutator: "link", Variation: "shared"}, {Mutator: "link", Variation: "shared"},
c.ImageVariation(), c.ImageVariation(),
}...), earlySharedDepTag, runtimeLibrary) }...), earlySharedDepTag, runtimeLibrary)
}
// static lib does not have dependency to the runtime library. The
// dependency will be added to the executables or shared libs using
// the static lib.
} else {
if c.sanitize.Properties.UbsanRuntimeDep {
// Support UBSan runtime on host modules, which requires the builtins linked in as well.
mctx.AddFarVariationDependencies(append(mctx.Target().Variations(), []blueprint.Variation{
{Mutator: "link", Variation: "static"},
c.ImageVariation(),
}...), StaticDepTag, append([]string{runtimeLibrary, config.BuiltinsRuntimeLibrary(toolchain)},
extraStaticDeps...)...)
}
} }
// static lib does not have dependency to the runtime library. The
// dependency will be added to the executables or shared libs using
// the static lib.
} }
} }
} }