From 81d0950934bf43950b85ee4d7bfba9c08895a6a5 Mon Sep 17 00:00:00 2001
From: Liz Kammer <eakammer@google.com>
Date: Mon, 31 Oct 2022 14:44:46 -0400
Subject: [PATCH] Extend lto_test

Test: go test soong cc tests
Change-Id: I3ddc53f0984b7cd4b40ff17b1f93a9b4db62f94c
---
 cc/lto_test.go | 105 ++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 96 insertions(+), 9 deletions(-)

diff --git a/cc/lto_test.go b/cc/lto_test.go
index b52f2b6a3..afd2c774e 100644
--- a/cc/lto_test.go
+++ b/cc/lto_test.go
@@ -24,29 +24,35 @@ import (
 
 func TestThinLtoDeps(t *testing.T) {
 	bp := `
-	cc_library {
+	cc_library_shared {
 		name: "lto_enabled",
 		srcs: ["src.c"],
-		static_libs: ["foo"],
+		static_libs: ["foo", "lib_never_lto"],
 		shared_libs: ["bar"],
 		lto: {
 			thin: true,
 		}
 	}
-	cc_library {
+	cc_library_static {
 		name: "foo",
 		static_libs: ["baz"],
 	}
-	cc_library {
+	cc_library_shared {
 		name: "bar",
 		static_libs: ["qux"],
 	}
-	cc_library {
+	cc_library_static {
 		name: "baz",
 	}
-	cc_library {
+	cc_library_static {
 		name: "qux",
 	}
+	cc_library_static {
+		name: "lib_never_lto",
+		lto: {
+			never: true,
+		},
+	}
 `
 
 	result := android.GroupFixturePreparers(
@@ -54,8 +60,6 @@ func TestThinLtoDeps(t *testing.T) {
 	).RunTestWithBp(t, bp)
 
 	libLto := result.ModuleForTests("lto_enabled", "android_arm64_armv8-a_shared").Module()
-	libFoo := result.ModuleForTests("foo", "android_arm64_armv8-a_static_lto-thin").Module()
-	libBaz := result.ModuleForTests("baz", "android_arm64_armv8-a_static_lto-thin").Module()
 
 	hasDep := func(m android.Module, wantDep android.Module) bool {
 		var found bool
@@ -67,12 +71,24 @@ func TestThinLtoDeps(t *testing.T) {
 		return found
 	}
 
+	libFoo := result.ModuleForTests("foo", "android_arm64_armv8-a_static_lto-thin").Module()
 	if !hasDep(libLto, libFoo) {
 		t.Errorf("'lto_enabled' missing dependency on thin lto variant of 'foo'")
 	}
 
+	libBaz := result.ModuleForTests("baz", "android_arm64_armv8-a_static_lto-thin").Module()
 	if !hasDep(libFoo, libBaz) {
-		t.Errorf("'lto_enabled' missing dependency on thin lto variant of transitive dep 'baz'")
+		t.Errorf("'foo' missing dependency on thin lto variant of transitive dep 'baz'")
+	}
+
+	libNeverLto := result.ModuleForTests("lib_never_lto", "android_arm64_armv8-a_static_lto-thin").Module()
+	if !hasDep(libLto, libNeverLto) {
+		t.Errorf("'lto_enabled' missing dependency on NO-thin lto variant of 'lib_never_lto'")
+	}
+
+	libBar := result.ModuleForTests("bar", "android_arm64_armv8-a_shared").Module()
+	if !hasDep(libLto, libBar) {
+		t.Errorf("'lto_enabled' missing dependency on non-thin lto variant of 'bar'")
 	}
 
 	barVariants := result.ModuleVariantsForTests("bar")
@@ -88,3 +104,74 @@ func TestThinLtoDeps(t *testing.T) {
 		}
 	}
 }
+
+func TestThinLtoOnlyOnStaticDep(t *testing.T) {
+	bp := `
+	cc_library_shared {
+		name: "root",
+		srcs: ["src.c"],
+		static_libs: ["foo"],
+	}
+	cc_library_shared {
+		name: "root_no_lto",
+		srcs: ["src.c"],
+		static_libs: ["foo"],
+		lto: {
+			never: true,
+		}
+	}
+	cc_library_static {
+		name: "foo",
+		srcs: ["foo.c"],
+		static_libs: ["baz"],
+		lto: {
+			thin: true,
+		}
+	}
+	cc_library_static {
+		name: "baz",
+		srcs: ["baz.c"],
+	}
+`
+
+	result := android.GroupFixturePreparers(
+		prepareForCcTest,
+	).RunTestWithBp(t, bp)
+
+	libRoot := result.ModuleForTests("root", "android_arm64_armv8-a_shared").Module()
+	libRootLtoNever := result.ModuleForTests("root_no_lto", "android_arm64_armv8-a_shared").Module()
+
+	hasDep := func(m android.Module, wantDep android.Module) bool {
+		var found bool
+		result.VisitDirectDeps(m, func(dep blueprint.Module) {
+			if dep == wantDep {
+				found = true
+			}
+		})
+		return found
+	}
+
+	libFoo := result.ModuleForTests("foo", "android_arm64_armv8-a_static")
+	if !hasDep(libRoot, libFoo.Module()) {
+		t.Errorf("'root' missing dependency on thin lto variant of 'foo'")
+	}
+
+	if !hasDep(libRootLtoNever, libFoo.Module()) {
+		t.Errorf("'root_no_lto' missing dependency on thin lto variant of 'foo'")
+	}
+
+	libFooCFlags := libFoo.Rule("cc").Args["cFlags"]
+	if w := "-flto=thin -fsplit-lto-unit"; !strings.Contains(libFooCFlags, w) {
+		t.Errorf("'foo' expected to have flags %q, but got %q", w, libFooCFlags)
+	}
+
+	libBaz := result.ModuleForTests("baz", "android_arm64_armv8-a_static_lto-thin")
+	if !hasDep(libFoo.Module(), libBaz.Module()) {
+		t.Errorf("'foo' missing dependency on thin lto variant of transitive dep 'baz'")
+	}
+
+	libBazCFlags := libFoo.Rule("cc").Args["cFlags"]
+	if w := "-flto=thin -fsplit-lto-unit"; !strings.Contains(libBazCFlags, w) {
+		t.Errorf("'baz' expected to have flags %q, but got %q", w, libFooCFlags)
+	}
+}