diff --git a/android/paths.go b/android/paths.go
index b192a35..128ec12 100644
--- a/android/paths.go
+++ b/android/paths.go
@@ -1591,6 +1591,18 @@
 // PathForModuleInstall returns a Path representing the install path for the
 // module appended with paths...
 func PathForModuleInstall(ctx ModuleInstallPathContext, pathComponents ...string) InstallPath {
+	os, arch := osAndArch(ctx)
+	partition := modulePartition(ctx, os)
+	return makePathForInstall(ctx, os, arch, partition, ctx.Debug(), pathComponents...)
+}
+
+// PathForModuleInPartitionInstall is similar to PathForModuleInstall but partition is provided by the caller
+func PathForModuleInPartitionInstall(ctx ModuleInstallPathContext, partition string, pathComponents ...string) InstallPath {
+	os, arch := osAndArch(ctx)
+	return makePathForInstall(ctx, os, arch, partition, ctx.Debug(), pathComponents...)
+}
+
+func osAndArch(ctx ModuleInstallPathContext) (OsType, ArchType) {
 	os := ctx.Os()
 	arch := ctx.Arch().ArchType
 	forceOS, forceArch := ctx.InstallForceOS()
@@ -1600,14 +1612,14 @@
 	if forceArch != nil {
 		arch = *forceArch
 	}
-	partition := modulePartition(ctx, os)
+	return os, arch
+}
 
-	ret := pathForInstall(ctx, os, arch, partition, ctx.Debug(), pathComponents...)
-
+func makePathForInstall(ctx ModuleInstallPathContext, os OsType, arch ArchType, partition string, debug bool, pathComponents ...string) InstallPath {
+	ret := pathForInstall(ctx, os, arch, partition, debug, pathComponents...)
 	if ctx.InstallBypassMake() && ctx.Config().KatiEnabled() {
 		ret = ret.ToMakePath()
 	}
-
 	return ret
 }
 
diff --git a/cc/cc.go b/cc/cc.go
index 7c4ba44..8bf27d3 100644
--- a/cc/cc.go
+++ b/cc/cc.go
@@ -1970,9 +1970,13 @@
 		if minSdkVersion == "" || minSdkVersion == "apex_inherit" {
 			minSdkVersion = m.SdkVersion()
 		}
+		apiLevel, err := android.ApiLevelFromUser(ctx, minSdkVersion)
+		if err != nil {
+			ctx.PropertyErrorf("min_sdk_version", err.Error())
+		}
 		return []blueprint.Variation{
 			{Mutator: "sdk", Variation: "sdk"},
-			{Mutator: "version", Variation: minSdkVersion},
+			{Mutator: "version", Variation: apiLevel.String()},
 		}
 	}
 	return []blueprint.Variation{
diff --git a/cc/ndk_abi.go b/cc/ndk_abi.go
index b9b57af..927fa2e 100644
--- a/cc/ndk_abi.go
+++ b/cc/ndk_abi.go
@@ -46,7 +46,7 @@
 
 		if m, ok := module.(*Module); ok {
 			if installer, ok := m.installer.(*stubDecorator); ok {
-				if canDumpAbi(m) {
+				if canDumpAbi() {
 					depPaths = append(depPaths, installer.abiDumpPath)
 				}
 			}
diff --git a/cc/ndk_library.go b/cc/ndk_library.go
index f3d2ba1..a458380 100644
--- a/cc/ndk_library.go
+++ b/cc/ndk_library.go
@@ -17,6 +17,7 @@
 import (
 	"fmt"
 	"path/filepath"
+	"runtime"
 	"strings"
 	"sync"
 
@@ -332,12 +333,12 @@
 }
 
 // Feature flag.
-func canDumpAbi(module android.Module) bool {
-	return true
+func canDumpAbi() bool {
+	return runtime.GOOS != "darwin"
 }
 
 // Feature flag to disable diffing against prebuilts.
-func canDiffAbi(module android.Module) bool {
+func canDiffAbi() bool {
 	return false
 }
 
@@ -452,9 +453,9 @@
 	nativeAbiResult := parseNativeAbiDefinition(ctx, symbolFile, c.apiLevel, "")
 	objs := compileStubLibrary(ctx, flags, nativeAbiResult.stubSrc)
 	c.versionScriptPath = nativeAbiResult.versionScript
-	if canDumpAbi(ctx.Module()) {
+	if canDumpAbi() {
 		c.dumpAbi(ctx, nativeAbiResult.symbolList)
-		if canDiffAbi(ctx.Module()) {
+		if canDiffAbi() {
 			c.diffAbi(ctx)
 		}
 	}
diff --git a/cc/sabi.go b/cc/sabi.go
index 384dcc1..1f331cb 100644
--- a/cc/sabi.go
+++ b/cc/sabi.go
@@ -192,7 +192,7 @@
 			// Mark all of its static library dependencies.
 			mctx.VisitDirectDeps(func(child android.Module) {
 				depTag := mctx.OtherModuleDependencyTag(child)
-				if libDepTag, ok := depTag.(libraryDependencyTag); ok && libDepTag.static() {
+				if IsStaticDepTag(depTag) || depTag == reuseObjTag {
 					if c, ok := child.(*Module); ok && c.sabi != nil {
 						// Mark this module so that .sdump for this static library can be generated.
 						c.sabi.Properties.ShouldCreateSourceAbiDump = true
diff --git a/cmd/multiproduct_kati/main.go b/cmd/multiproduct_kati/main.go
index 20f146a..55a5470 100644
--- a/cmd/multiproduct_kati/main.go
+++ b/cmd/multiproduct_kati/main.go
@@ -460,19 +460,21 @@
 		}
 	}()
 
-	buildWhat := build.BuildProductConfig
+	config.SetSkipNinja(true)
+
+	buildWhat := build.RunProductConfig
 	if !*onlyConfig {
-		buildWhat |= build.BuildSoong
+		buildWhat |= build.RunSoong
 		if !*onlySoong {
-			buildWhat |= build.BuildKati
+			buildWhat |= build.RunKati
 		}
 	}
 
 	before := time.Now()
-	build.Build(ctx, config, buildWhat)
+	build.Build(ctx, config)
 
 	// Save std_full.log if Kati re-read the makefiles
-	if buildWhat&build.BuildKati != 0 {
+	if buildWhat&build.RunKati != 0 {
 		if after, err := os.Stat(config.KatiBuildNinjaFile()); err == nil && after.ModTime().After(before) {
 			err := copyFile(stdLog, filepath.Join(filepath.Dir(stdLog), "std_full.log"))
 			if err != nil {
diff --git a/cmd/soong_ui/main.go b/cmd/soong_ui/main.go
index 390a9ec..22922c0 100644
--- a/cmd/soong_ui/main.go
+++ b/cmd/soong_ui/main.go
@@ -59,12 +59,10 @@
 	run func(ctx build.Context, config build.Config, args []string, logsDir string)
 }
 
-const makeModeFlagName = "--make-mode"
-
 // list of supported commands (flags) supported by soong ui
 var commands []command = []command{
 	{
-		flag:        makeModeFlagName,
+		flag:        "--make-mode",
 		description: "build the modules by the target name (i.e. soong_docs)",
 		config: func(ctx build.Context, args ...string) build.Config {
 			return build.NewConfig(ctx, args...)
@@ -506,15 +504,7 @@
 		ctx.Fatal("done")
 	}
 
-	toBuild := build.BuildAll
-	if config.UseBazel() {
-		toBuild = build.BuildAllWithBazel
-	}
-
-	if config.Checkbuild() {
-		toBuild |= build.RunBuildTests
-	}
-	build.Build(ctx, config, toBuild)
+	build.Build(ctx, config)
 }
 
 // getCommand finds the appropriate command based on args[1] flag. args[0]
diff --git a/cuj/cuj.go b/cuj/cuj.go
index 3333012..b4ae9a2 100644
--- a/cuj/cuj.go
+++ b/cuj/cuj.go
@@ -115,7 +115,7 @@
 	defer f.Shutdown()
 	build.FindSources(buildCtx, config, f)
 
-	build.Build(buildCtx, config, build.BuildAll)
+	build.Build(buildCtx, config)
 
 	t.results.metrics = met
 }
diff --git a/java/bootclasspath_fragment.go b/java/bootclasspath_fragment.go
index 792193f..1c7ad78 100644
--- a/java/bootclasspath_fragment.go
+++ b/java/bootclasspath_fragment.go
@@ -516,7 +516,16 @@
 	// Only create configs for updatable boot jars. Non-updatable boot jars must be part of the
 	// platform_bootclasspath's classpath proto config to guarantee that they come before any
 	// updatable jars at runtime.
-	return global.UpdatableBootJars.Filter(stems)
+	jars := global.UpdatableBootJars.Filter(stems)
+
+	// TODO(satayev): for apex_test we want to include all contents unconditionally to classpaths
+	// config. However, any test specific jars would not be present in UpdatableBootJars. Instead,
+	// we should check if we are creating a config for apex_test via ApexInfo and amend the values.
+	// This is an exception to support end-to-end test for SdkExtensions, until such support exists.
+	if android.InList("test_framework-sdkextensions", stems) {
+		jars = jars.Append("com.android.sdkext", "test_framework-sdkextensions")
+	}
+	return jars
 }
 
 func (b *BootclasspathFragmentModule) getImageConfig(ctx android.EarlyModuleContext) *bootImageConfig {
diff --git a/java/droiddoc.go b/java/droiddoc.go
index 56e6247..869a598 100644
--- a/java/droiddoc.go
+++ b/java/droiddoc.go
@@ -425,23 +425,6 @@
 	}
 	srcFiles = filterByPackage(srcFiles, j.properties.Filter_packages)
 
-	// While metalava needs package html files, it does not need them to be explicit on the command
-	// line. javadoc complains if it receives html files on the command line. The filter
-	// below excludes html files from the rsp file metalava. Note that the html
-	// files are still included as implicit inputs for successful remote execution and correct
-	// incremental builds.
-	filterHtml := func(srcs []android.Path) []android.Path {
-		filtered := []android.Path{}
-		for _, src := range srcs {
-			if src.Ext() == ".html" {
-				continue
-			}
-			filtered = append(filtered, src)
-		}
-		return filtered
-	}
-	srcFiles = filterHtml(srcFiles)
-
 	aidlFlags := j.collectAidlFlags(ctx, deps)
 	srcFiles = j.genSources(ctx, srcFiles, aidlFlags)
 
diff --git a/java/droidstubs.go b/java/droidstubs.go
index 3607082..d348b55 100644
--- a/java/droidstubs.go
+++ b/java/droidstubs.go
@@ -392,22 +392,11 @@
 }
 
 func metalavaCmd(ctx android.ModuleContext, rule *android.RuleBuilder, javaVersion javaVersion, srcs android.Paths,
-	srcJarList android.Path, bootclasspath, classpath classpath, sourcepaths android.Paths,
-	homeDir android.WritablePath) *android.RuleBuilderCommand {
+	srcJarList android.Path, bootclasspath, classpath classpath, homeDir android.WritablePath) *android.RuleBuilderCommand {
 	rule.Command().Text("rm -rf").Flag(homeDir.String())
 	rule.Command().Text("mkdir -p").Flag(homeDir.String())
 
-	var cmd *android.RuleBuilderCommand
-	if len(sourcepaths) > 0 {
-		// We are passing the sourcepaths as an argument to metalava below, but the directories may
-		// not exist already (if they do not contain any listed inputs for metalava). Note that this
-		// is in a rule.SboxInputs()rule, so we are not modifying the actual source tree by creating
-		// these directories.
-		cmd = rule.Command()
-		cmd.Text("mkdir -p").Flags(cmd.PathsForInputs(sourcepaths))
-	}
-
-	cmd = rule.Command()
+	cmd := rule.Command()
 	cmd.FlagWithArg("ANDROID_PREFS_ROOT=", homeDir.String())
 
 	if ctx.Config().UseRBE() && ctx.Config().IsEnvTrue("RBE_METALAVA") {
@@ -440,13 +429,6 @@
 		cmd.FlagWithInputList("-classpath ", classpath.Paths(), ":")
 	}
 
-	if len(sourcepaths) > 0 {
-		// TODO(b/153703940): Pass .html files to metalava and remove this argument.
-		cmd.FlagWithList("-sourcepath ", sourcepaths.Strings(), ":")
-	} else {
-		cmd.FlagWithArg("-sourcepath ", `""`)
-	}
-
 	cmd.Flag("--no-banner").
 		Flag("--color").
 		Flag("--quiet").
@@ -490,7 +472,7 @@
 
 	homeDir := android.PathForModuleOut(ctx, "metalava", "home")
 	cmd := metalavaCmd(ctx, rule, javaVersion, d.Javadoc.srcFiles, srcJarList,
-		deps.bootClasspath, deps.classpath, d.Javadoc.sourcepaths, homeDir)
+		deps.bootClasspath, deps.classpath, homeDir)
 	cmd.Implicits(d.Javadoc.implicits)
 
 	d.stubsFlags(ctx, cmd, stubsDir)
diff --git a/java/rro.go b/java/rro.go
index 2e58c04..0b4d091 100644
--- a/java/rro.go
+++ b/java/rro.go
@@ -90,6 +90,22 @@
 	Theme() string
 }
 
+// RRO's partition logic is different from the partition logic of other modules defined in soong/android/paths.go
+// The default partition for RRO is "/product" and not "/system"
+func rroPartition(ctx android.ModuleContext) string {
+	var partition string
+	if ctx.DeviceSpecific() {
+		partition = ctx.DeviceConfig().OdmPath()
+	} else if ctx.SocSpecific() {
+		partition = ctx.DeviceConfig().VendorPath()
+	} else if ctx.SystemExtSpecific() {
+		partition = ctx.DeviceConfig().SystemExtPath()
+	} else {
+		partition = ctx.DeviceConfig().ProductPath()
+	}
+	return partition
+}
+
 func (r *RuntimeResourceOverlay) DepsMutator(ctx android.BottomUpMutatorContext) {
 	sdkDep := decodeSdkDep(ctx, android.SdkContext(r))
 	if sdkDep.hasFrameworkLibs() {
@@ -137,7 +153,8 @@
 	r.certificate = certificates[0]
 
 	r.outputFile = signed
-	r.installDir = android.PathForModuleInstall(ctx, "overlay", String(r.properties.Theme))
+	partition := rroPartition(ctx)
+	r.installDir = android.PathForModuleInPartitionInstall(ctx, partition, "overlay", String(r.properties.Theme))
 	ctx.InstallFile(r.installDir, r.outputFile.Base(), r.outputFile)
 }
 
diff --git a/java/rro_test.go b/java/rro_test.go
index bad60bc..27abbe4 100644
--- a/java/rro_test.go
+++ b/java/rro_test.go
@@ -177,7 +177,7 @@
 
 	// Check device location.
 	path = android.AndroidMkEntriesForTest(t, ctx, m.Module())[0].EntryMap["LOCAL_MODULE_PATH"]
-	expectedPath = []string{shared.JoinPath("out/target/product/test_device/system/overlay")}
+	expectedPath = []string{shared.JoinPath("out/target/product/test_device/product/overlay")}
 	android.AssertStringPathsRelativeToTopEquals(t, "LOCAL_MODULE_PATH", config, expectedPath, path)
 }
 
@@ -343,3 +343,57 @@
 		})
 	}
 }
+
+func TestRuntimeResourceOverlayPartition(t *testing.T) {
+	bp := `
+		runtime_resource_overlay {
+			name: "device_specific",
+			device_specific: true,
+		}
+		runtime_resource_overlay {
+			name: "soc_specific",
+			soc_specific: true,
+		}
+		runtime_resource_overlay {
+			name: "system_ext_specific",
+			system_ext_specific: true,
+		}
+		runtime_resource_overlay {
+			name: "product_specific",
+			product_specific: true,
+		}
+		runtime_resource_overlay {
+			name: "default"
+		}
+	`
+	testCases := []struct {
+		name         string
+		expectedPath string
+	}{
+		{
+			name:         "device_specific",
+			expectedPath: "out/soong/target/product/test_device/odm/overlay",
+		},
+		{
+			name:         "soc_specific",
+			expectedPath: "out/soong/target/product/test_device/vendor/overlay",
+		},
+		{
+			name:         "system_ext_specific",
+			expectedPath: "out/soong/target/product/test_device/system_ext/overlay",
+		},
+		{
+			name:         "product_specific",
+			expectedPath: "out/soong/target/product/test_device/product/overlay",
+		},
+		{
+			name:         "default",
+			expectedPath: "out/soong/target/product/test_device/product/overlay",
+		},
+	}
+	for _, testCase := range testCases {
+		ctx, _ := testJava(t, bp)
+		mod := ctx.ModuleForTests(testCase.name, "android_common").Module().(*RuntimeResourceOverlay)
+		android.AssertPathRelativeToTopEquals(t, "Install dir is not correct for "+testCase.name, testCase.expectedPath, mod.installDir)
+	}
+}
diff --git a/java/sdk_library.go b/java/sdk_library.go
index ecf2b1a..9492729 100644
--- a/java/sdk_library.go
+++ b/java/sdk_library.go
@@ -435,9 +435,6 @@
 	// a list of top-level directories containing Java stub files to merge show/hide annotations from.
 	Merge_inclusion_annotations_dirs []string
 
-	// If set to true, the path of dist files is apistubs/core. Defaults to false.
-	Core_lib *bool
-
 	// If set to true then don't create dist rules.
 	No_dist *bool
 
@@ -458,7 +455,7 @@
 	Dist_stem *string
 
 	// The subdirectory for the artifacts that are copied to the dist directory.  If not specified
-	// then defaults to "android".  Should be set to "android" for anything that should be published
+	// then defaults to "unknown".  Should be set to "android" for anything that should be published
 	// in the public Android SDK.
 	Dist_group *string
 
@@ -1203,11 +1200,7 @@
 
 // The dist path of the stub artifacts
 func (module *SdkLibrary) apiDistPath(apiScope *apiScope) string {
-	if Bool(module.sdkLibraryProperties.Core_lib) {
-		return path.Join("apistubs", "core", apiScope.name)
-	} else {
-		return path.Join("apistubs", module.distGroup(), apiScope.name)
-	}
+	return path.Join("apistubs", module.distGroup(), apiScope.name)
 }
 
 // Get the sdk version for use when compiling the stubs library.
@@ -1233,15 +1226,7 @@
 
 // distGroup returns the subdirectory of the dist path of the stub artifacts.
 func (module *SdkLibrary) distGroup() string {
-	if group := proptools.String(module.sdkLibraryProperties.Dist_group); group != "" {
-		return group
-	}
-	// TODO(b/186723288): Remove this once everything uses dist_group.
-	if owner := module.ModuleBase.Owner(); owner != "" {
-		return owner
-	}
-	// TODO(b/186723288): Make this "unknown".
-	return "android"
+	return proptools.StringDefault(module.sdkLibraryProperties.Dist_group, "unknown")
 }
 
 func (module *SdkLibrary) latestApiFilegroupName(apiScope *apiScope) string {
diff --git a/java/sdk_library_test.go b/java/sdk_library_test.go
index 0fe6e72..2520dde 100644
--- a/java/sdk_library_test.go
+++ b/java/sdk_library_test.go
@@ -844,40 +844,34 @@
 		PrepareForTestWithJavaBuildComponents,
 		PrepareForTestWithJavaDefaultModules,
 		PrepareForTestWithJavaSdkLibraryFiles,
+		FixtureWithLastReleaseApis(
+			"sdklib_no_group",
+			"sdklib_group_foo",
+			"sdklib_owner_foo",
+			"foo"),
 	).RunTestWithBp(t, `
 		java_sdk_library {
-			name: "sdklib_no_owner",
-			unsafe_ignore_missing_latest_api: true,
+			name: "sdklib_no_group",
 			srcs: ["foo.java"],
 		}
 
 		java_sdk_library {
 			name: "sdklib_group_foo",
-			unsafe_ignore_missing_latest_api: true,
 			srcs: ["foo.java"],
 			dist_group: "foo",
 		}
 
 		java_sdk_library {
 			name: "sdklib_owner_foo",
-			unsafe_ignore_missing_latest_api: true,
 			srcs: ["foo.java"],
 			owner: "foo",
 		}
 
 		java_sdk_library {
 			name: "sdklib_stem_foo",
-			unsafe_ignore_missing_latest_api: true,
 			srcs: ["foo.java"],
 			dist_stem: "foo",
 		}
-
-		java_sdk_library {
-			name: "sdklib_core_lib",
-			unsafe_ignore_missing_latest_api: true,
-			srcs: ["foo.java"],
-			core_lib: true,
-		}
 	`)
 
 	type testCase struct {
@@ -887,9 +881,9 @@
 	}
 	testCases := []testCase{
 		{
-			module:   "sdklib_no_owner",
-			distDir:  "apistubs/android/public",
-			distStem: "sdklib_no_owner.jar",
+			module:   "sdklib_no_group",
+			distDir:  "apistubs/unknown/public",
+			distStem: "sdklib_no_group.jar",
 		},
 		{
 			module:   "sdklib_group_foo",
@@ -897,20 +891,16 @@
 			distStem: "sdklib_group_foo.jar",
 		},
 		{
+			// Owner doesn't affect distDir after b/186723288.
 			module:   "sdklib_owner_foo",
-			distDir:  "apistubs/foo/public",
+			distDir:  "apistubs/unknown/public",
 			distStem: "sdklib_owner_foo.jar",
 		},
 		{
 			module:   "sdklib_stem_foo",
-			distDir:  "apistubs/android/public",
+			distDir:  "apistubs/unknown/public",
 			distStem: "foo.jar",
 		},
-		{
-			module:   "sdklib_core_lib",
-			distDir:  "apistubs/core/public",
-			distStem: "sdklib_core_lib.jar",
-		},
 	}
 
 	for _, tt := range testCases {
diff --git a/scripts/build-aml-prebuilts.sh b/scripts/build-aml-prebuilts.sh
index 4b08ac3..8a5513e 100755
--- a/scripts/build-aml-prebuilts.sh
+++ b/scripts/build-aml-prebuilts.sh
@@ -1,14 +1,24 @@
 #!/bin/bash -e
 
-# This is a wrapper around "m" that builds the given modules in multi-arch mode
-# for all architectures supported by Mainline modules. The make (kati) stage is
-# skipped, so the build targets in the arguments can only be Soong modules or
-# intermediate output files - make targets and normal installed paths are not
-# supported.
+# This script is similar to "m" but builds in --soong-only mode, and handles
+# special cases to make that mode work. All arguments are passed on to
+# build/soong/soong_ui.bash.
 #
-# This script is typically used with "sdk" or "module_export" modules, which
-# Soong will install in $OUT_DIR/soong/mainline-sdks (cf
-# PathForMainlineSdksInstall in android/paths.go).
+# --soong-only bypasses the kati step and hence the make logic that e.g. doesn't
+# handle more than two device architectures. It is particularly intended for use
+# with TARGET_PRODUCT=mainline_sdk to build 'sdk' and 'module_export' Soong
+# modules in TARGET_ARCH_SUITE=mainline_sdk mode so that they get all four
+# device architectures (artifacts get installed in $OUT_DIR/soong/mainline-sdks
+# - cf PathForMainlineSdksInstall in android/paths.go).
+#
+# TODO(b/174315599): Replace this script completely with a 'soong_ui.bash
+# --soong-only' invocation. For now it is still necessary to set up
+# build_number.txt.
+
+if [ ! -e build/soong/soong_ui.bash ]; then
+  echo "$0 must be run from the top of the tree"
+  exit 1
+fi
 
 export OUT_DIR=${OUT_DIR:-out}
 
@@ -23,109 +33,19 @@
   OUT_DIR=${AML_OUT_DIR}
 fi
 
-if [ ! -e "build/envsetup.sh" ]; then
-  echo "$0 must be run from the top of the tree"
-  exit 1
-fi
+mkdir -p ${OUT_DIR}/soong
 
-source build/envsetup.sh
-
-my_get_build_var() {
-  # get_build_var will run Soong in normal in-make mode where it creates
-  # .soong.kati_enabled. That would clobber our real out directory, so we need
-  # to run it in a different one.
-  OUT_DIR=${OUT_DIR}/get_build_var get_build_var "$@"
-}
-
-readonly SOONG_OUT=${OUT_DIR}/soong
-mkdir -p ${SOONG_OUT}
+# The --dumpvars-mode invocation will run Soong in normal make mode where it
+# creates .soong.kati_enabled. That would clobber our real out directory, so we
+# need to use a different OUT_DIR.
+vars="$(OUT_DIR=${OUT_DIR}/dumpvars_mode build/soong/soong_ui.bash \
+        --dumpvars-mode --vars=BUILD_NUMBER)"
+# Assign to a variable and eval that, since bash ignores any error status
+# from the command substitution if it's directly on the eval line.
+eval $vars
 
 # Some Soong build rules may require this, and the failure mode if it's missing
 # is confusing (b/172548608).
-readonly BUILD_NUMBER="$(my_get_build_var BUILD_NUMBER)"
-echo -n ${BUILD_NUMBER} > ${SOONG_OUT}/build_number.txt
+echo -n ${BUILD_NUMBER} > ${OUT_DIR}/soong/build_number.txt
 
-readonly PLATFORM_SDK_VERSION="$(my_get_build_var PLATFORM_SDK_VERSION)"
-readonly PLATFORM_VERSION="$(my_get_build_var PLATFORM_VERSION)"
-PLATFORM_VERSION_ALL_CODENAMES="$(my_get_build_var PLATFORM_VERSION_ALL_CODENAMES)"
-
-# PLATFORM_VERSION_ALL_CODENAMES is a comma separated list like O,P. We need to
-# turn this into ["O","P"].
-PLATFORM_VERSION_ALL_CODENAMES="${PLATFORM_VERSION_ALL_CODENAMES/,/'","'}"
-PLATFORM_VERSION_ALL_CODENAMES="[\"${PLATFORM_VERSION_ALL_CODENAMES}\"]"
-
-# Get the list of missing <uses-library> modules and convert it to a JSON array
-# (quote module names, add comma separator and wrap in brackets).
-MISSING_USES_LIBRARIES="$(my_get_build_var INTERNAL_PLATFORM_MISSING_USES_LIBRARIES)"
-MISSING_USES_LIBRARIES="[$(echo $MISSING_USES_LIBRARIES | sed -e 's/\([^ ]\+\)/\"\1\"/g' -e 's/[ ]\+/, /g')]"
-
-# Logic from build/make/core/goma.mk
-if [ "${USE_GOMA}" = true ]; then
-  if [ -n "${GOMA_DIR}" ]; then
-    goma_dir="${GOMA_DIR}"
-  else
-    goma_dir="${HOME}/goma"
-  fi
-  GOMA_CC="${goma_dir}/gomacc"
-  export CC_WRAPPER="${CC_WRAPPER}${CC_WRAPPER:+ }${GOMA_CC}"
-  export CXX_WRAPPER="${CXX_WRAPPER}${CXX_WRAPPER:+ }${GOMA_CC}"
-  export JAVAC_WRAPPER="${JAVAC_WRAPPER}${JAVAC_WRAPPER:+ }${GOMA_CC}"
-else
-  USE_GOMA=false
-fi
-
-readonly SOONG_VARS=${SOONG_OUT}/soong.variables
-
-# Aml_abis: true
-#   -  This flag configures Soong to compile for all architectures required for
-#      Mainline modules.
-# CrossHost: linux_bionic
-# CrossHostArch: x86_64
-#   -  Enable Bionic on host as ART needs prebuilts for it.
-# VendorVars.art_mdoule.source_build
-#   -  TODO(b/172480615): Change default to false when platform uses ART Module
-#      prebuilts by default.
-cat > ${SOONG_VARS}.new << EOF
-{
-    "BuildNumberFile": "build_number.txt",
-
-    "Platform_version_name": "${PLATFORM_VERSION}",
-    "Platform_sdk_version": ${PLATFORM_SDK_VERSION},
-    "Platform_sdk_codename": "${PLATFORM_VERSION}",
-    "Platform_version_active_codenames": ${PLATFORM_VERSION_ALL_CODENAMES},
-
-    "DeviceName": "generic_arm64",
-    "HostArch": "x86_64",
-    "HostSecondaryArch": "x86",
-    "CrossHost": "linux_bionic",
-    "CrossHostArch": "x86_64",
-    "Aml_abis": true,
-
-    "Allow_missing_dependencies": ${SOONG_ALLOW_MISSING_DEPENDENCIES:-false},
-    "Unbundled_build": ${TARGET_BUILD_UNBUNDLED:-false},
-    "UseGoma": ${USE_GOMA},
-
-    "VendorVars": {
-        "art_module": {
-            "source_build": "${ENABLE_ART_SOURCE_BUILD:-true}"
-        }
-    },
-
-    "MissingUsesLibraries": ${MISSING_USES_LIBRARIES}
-}
-EOF
-
-if [ -f ${SOONG_VARS} ] && cmp -s ${SOONG_VARS} ${SOONG_VARS}.new; then
-  # Don't touch soong.variables if we don't have to, to avoid Soong rebuilding
-  # the ninja file when it isn't necessary.
-  rm ${SOONG_VARS}.new
-else
-  mv ${SOONG_VARS}.new ${SOONG_VARS}
-fi
-
-# We use force building LLVM components flag (even though we actually don't
-# compile them) because we don't have bionic host prebuilts
-# for them.
-export FORCE_BUILD_LLVM_COMPONENTS=true
-
-m --skip-make "$@"
+build/soong/soong_ui.bash --make-mode --soong-only "$@"
diff --git a/scripts/build-mainline-modules.sh b/scripts/build-mainline-modules.sh
index 39c8fba..7d49492 100755
--- a/scripts/build-mainline-modules.sh
+++ b/scripts/build-mainline-modules.sh
@@ -93,11 +93,17 @@
   done
 done
 
+# We use force building LLVM components flag (even though we actually don't
+# compile them) because we don't have bionic host prebuilts
+# for them.
+export FORCE_BUILD_LLVM_COMPONENTS=true
+
 # Create multi-archs SDKs in a different out directory. The multi-arch script
 # uses Soong in --skip-make mode which cannot use the same directory as normal
 # mode with make.
 export OUT_DIR=${OUT_DIR}/aml
-echo_and_run build/soong/scripts/build-aml-prebuilts.sh ${MODULES_SDK_AND_EXPORTS[@]}
+echo_and_run build/soong/scripts/build-aml-prebuilts.sh \
+  TARGET_PRODUCT=mainline_sdk ${MODULES_SDK_AND_EXPORTS[@]}
 
 rm -rf ${DIST_DIR}/mainline-sdks
 echo_and_run cp -R ${OUT_DIR}/soong/mainline-sdks ${DIST_DIR}
diff --git a/ui/build/build.go b/ui/build/build.go
index c2ad057..8f050d9 100644
--- a/ui/build/build.go
+++ b/ui/build/build.go
@@ -60,15 +60,15 @@
 {{end -}}
 pool highmem_pool
  depth = {{.HighmemParallel}}
-{{if .HasKatiSuffix}}subninja {{.KatiBuildNinjaFile}}
+{{if and (not .SkipKatiNinja) .HasKatiSuffix}}subninja {{.KatiBuildNinjaFile}}
 subninja {{.KatiPackageNinjaFile}}
 {{end -}}
 subninja {{.SoongNinjaFile}}
 `))
 
 func createCombinedBuildNinjaFile(ctx Context, config Config) {
-	// If we're in SkipKati mode, skip creating this file if it already exists
-	if config.SkipKati() {
+	// If we're in SkipKati mode but want to run kati ninja, skip creating this file if it already exists
+	if config.SkipKati() && !config.SkipKatiNinja() {
 		if _, err := os.Stat(config.CombinedNinjaFile()); err == nil || !os.IsNotExist(err) {
 			return
 		}
@@ -87,15 +87,22 @@
 
 // These are bitmasks which can be used to check whether various flags are set e.g. whether to use Bazel.
 const (
-	BuildNone          = iota
-	BuildProductConfig = 1 << iota
-	BuildSoong         = 1 << iota
-	BuildKati          = 1 << iota
-	BuildNinja         = 1 << iota
-	BuildBazel         = 1 << iota
-	RunBuildTests      = 1 << iota
-	BuildAll           = BuildProductConfig | BuildSoong | BuildKati | BuildNinja
-	BuildAllWithBazel  = BuildProductConfig | BuildSoong | BuildKati | BuildBazel
+	_ = iota
+	// Whether to run the kati config step.
+	RunProductConfig = 1 << iota
+	// Whether to run soong to generate a ninja file.
+	RunSoong = 1 << iota
+	// Whether to run kati to generate a ninja file.
+	RunKati = 1 << iota
+	// Whether to include the kati-generated ninja file in the combined ninja.
+	RunKatiNinja = 1 << iota
+	// Whether to run ninja on the combined ninja.
+	RunNinja = 1 << iota
+	// Whether to run bazel on the combined ninja.
+	RunBazel        = 1 << iota
+	RunBuildTests   = 1 << iota
+	RunAll          = RunProductConfig | RunSoong | RunKati | RunKatiNinja | RunNinja
+	RunAllWithBazel = RunProductConfig | RunSoong | RunKati | RunKatiNinja | RunBazel
 )
 
 // checkProblematicFiles fails the build if existing Android.mk or CleanSpec.mk files are found at the root of the tree.
@@ -173,7 +180,7 @@
 
 // Build the tree. The 'what' argument can be used to chose which components of
 // the build to run, via checking various bitmasks.
-func Build(ctx Context, config Config, what int) {
+func Build(ctx Context, config Config) {
 	ctx.Verboseln("Starting build with args:", config.Arguments())
 	ctx.Verboseln("Environment:", config.Environment().Environ())
 
@@ -208,33 +215,39 @@
 
 	SetupPath(ctx, config)
 
+	what := RunAll
+	if config.UseBazel() {
+		what = RunAllWithBazel
+	}
+	if config.Checkbuild() {
+		what |= RunBuildTests
+	}
 	if config.SkipConfig() {
 		ctx.Verboseln("Skipping Config as requested")
-		what = what &^ BuildProductConfig
+		what = what &^ RunProductConfig
 	}
-
 	if config.SkipKati() {
 		ctx.Verboseln("Skipping Kati as requested")
-		what = what &^ BuildKati
+		what = what &^ RunKati
 	}
-
+	if config.SkipKatiNinja() {
+		ctx.Verboseln("Skipping use of Kati ninja as requested")
+		what = what &^ RunKatiNinja
+	}
 	if config.SkipNinja() {
 		ctx.Verboseln("Skipping Ninja as requested")
-		what = what &^ BuildNinja
+		what = what &^ RunNinja
 	}
 
 	if config.StartGoma() {
-		// Ensure start Goma compiler_proxy
 		startGoma(ctx, config)
 	}
 
 	if config.StartRBE() {
-		// Ensure RBE proxy is started
 		startRBE(ctx, config)
 	}
 
-	if what&BuildProductConfig != 0 {
-		// Run make for product config
+	if what&RunProductConfig != 0 {
 		runMakeProductConfig(ctx, config)
 	}
 
@@ -254,8 +267,7 @@
 		return
 	}
 
-	if what&BuildSoong != 0 {
-		// Run Soong
+	if what&RunSoong != 0 {
 		runSoong(ctx, config)
 
 		if config.bazelBuildMode() == generateBuildFiles {
@@ -264,15 +276,14 @@
 		}
 	}
 
-	if what&BuildKati != 0 {
-		// Run ckati
+	if what&RunKati != 0 {
 		genKatiSuffix(ctx, config)
 		runKatiCleanSpec(ctx, config)
 		runKatiBuild(ctx, config)
 		runKatiPackage(ctx, config)
 
 		ioutil.WriteFile(config.LastKatiSuffixFile(), []byte(config.KatiSuffix()), 0666) // a+rw
-	} else {
+	} else if what&RunKatiNinja != 0 {
 		// Load last Kati Suffix if it exists
 		if katiSuffix, err := ioutil.ReadFile(config.LastKatiSuffixFile()); err == nil {
 			ctx.Verboseln("Loaded previous kati config:", string(katiSuffix))
@@ -289,17 +300,16 @@
 		testForDanglingRules(ctx, config)
 	}
 
-	if what&BuildNinja != 0 {
-		if what&BuildKati != 0 {
+	if what&RunNinja != 0 {
+		if what&RunKati != 0 {
 			installCleanIfNecessary(ctx, config)
 		}
 
-		// Run ninja
 		runNinjaForBuild(ctx, config)
 	}
 
 	// Currently, using Bazel requires Kati and Soong to run first, so check whether to run Bazel last.
-	if what&BuildBazel != 0 {
+	if what&RunBazel != 0 {
 		runBazel(ctx, config)
 	}
 }
diff --git a/ui/build/config.go b/ui/build/config.go
index f1f5989..220e734 100644
--- a/ui/build/config.go
+++ b/ui/build/config.go
@@ -48,6 +48,7 @@
 	dist           bool
 	skipConfig     bool
 	skipKati       bool
+	skipKatiNinja  bool
 	skipNinja      bool
 	skipSoongTests bool
 
@@ -567,8 +568,7 @@
 func (c *configImpl) parseArgs(ctx Context, args []string) {
 	for i := 0; i < len(args); i++ {
 		arg := strings.TrimSpace(args[i])
-		if arg == "--make-mode" {
-		} else if arg == "showcommands" {
+		if arg == "showcommands" {
 			c.verbose = true
 		} else if arg == "--skip-ninja" {
 			c.skipNinja = true
@@ -576,7 +576,11 @@
 			c.skipConfig = true
 			c.skipKati = true
 		} else if arg == "--skip-kati" {
+			// TODO: remove --skip-kati once module builds have been migrated to --song-only
 			c.skipKati = true
+		} else if arg == "--soong-only" {
+			c.skipKati = true
+			c.skipKatiNinja = true
 		} else if arg == "--skip-soong-tests" {
 			c.skipSoongTests = true
 		} else if len(arg) > 0 && arg[0] == '-' {
@@ -792,10 +796,18 @@
 	return c.skipKati
 }
 
+func (c *configImpl) SkipKatiNinja() bool {
+	return c.skipKatiNinja
+}
+
 func (c *configImpl) SkipNinja() bool {
 	return c.skipNinja
 }
 
+func (c *configImpl) SetSkipNinja(v bool) {
+	c.skipNinja = v
+}
+
 func (c *configImpl) SkipConfig() bool {
 	return c.skipConfig
 }