diff --git a/dexpreopt/dexpreopt.go b/dexpreopt/dexpreopt.go
index 3605d9d..66e765f 100644
--- a/dexpreopt/dexpreopt.go
+++ b/dexpreopt/dexpreopt.go
@@ -328,9 +328,42 @@
 	return &classLoaderContexts
 }
 
+// Find build and install paths to "android.hidl.base". The library must be present in conditional
+// class loader context for SDK version 29, because it's one of the compatibility libraries.
+func findHidlBasePaths(ctx android.PathContext, clcMap classLoaderContextMap) (android.Path, string) {
+	var hostPath android.Path
+	targetPath := UnknownInstallLibraryPath
+
+	if clc, ok := clcMap[29]; ok {
+		for i, lib := range clc.Names {
+			if lib == AndroidHidlBase {
+				hostPath = clc.Host[i]
+				targetPath = clc.Target[i]
+				break
+			}
+		}
+	}
+
+	// Fail if the library paths were not found. This may happen if the function is called at the
+	// wrong time (either before the compatibility libraries were added to context, or after they
+	// have been removed for some reason).
+	if hostPath == nil {
+		android.ReportPathErrorf(ctx, "dexpreopt cannot find build path to '%s'", AndroidHidlBase)
+	} else if targetPath == UnknownInstallLibraryPath {
+		android.ReportPathErrorf(ctx, "dexpreopt cannot find install path to '%s'", AndroidHidlBase)
+	}
+
+	return hostPath, targetPath
+}
+
 // Now that the full unconditional context is known, reconstruct conditional context.
 // Apply filters for individual libraries, mirroring what the PackageManager does when it
 // constructs class loader context on device.
+//
+// TODO(b/132357300):
+//   - move handling of android.hidl.manager -> android.hidl.base dependency here
+//   - remove android.hidl.manager and android.hidl.base unless the app is a system app.
+//
 func fixConditionalClassLoaderContext(clcMap classLoaderContextMap) {
 	usesLibs := clcMap.usesLibs()
 
@@ -352,6 +385,52 @@
 	}
 }
 
+// Return the class loader context as a string and a slice of build paths for all dependencies.
+func computeClassLoaderContext(ctx android.PathContext, clcMap classLoaderContextMap) (clcStr string, paths android.Paths) {
+	hidlBaseHostPath, hidlBaseTargetPath := findHidlBasePaths(ctx, clcMap)
+
+	for _, ver := range android.SortedIntKeys(clcMap) {
+		clc := clcMap.getValue(ver)
+
+		clcLen := len(clc.Names)
+		if clcLen != len(clc.Host) || clcLen != len(clc.Target) {
+			android.ReportPathErrorf(ctx, "ill-formed class loader context")
+		}
+
+		var hostClc, targetClc []string
+		var hostPaths android.Paths
+
+		for i := 0; i < clcLen; i++ {
+			hostStr := "PCL[" + clc.Host[i].String() + "]"
+			targetStr := "PCL[" + clc.Target[i] + "]"
+
+			// Add dependency of android.hidl.manager on android.hidl.base (it is not tracked as
+			// a regular dependency by the build system, so it needs special handling).
+			if clc.Names[i] == AndroidHidlManager {
+				hostStr += "{PCL[" + hidlBaseHostPath.String() + "]}"
+				targetStr += "{PCL[" + hidlBaseTargetPath + "]}"
+				hostPaths = append(hostPaths, hidlBaseHostPath)
+			}
+
+			hostClc = append(hostClc, hostStr)
+			targetClc = append(targetClc, targetStr)
+			hostPaths = append(hostPaths, clc.Host[i])
+		}
+
+		if hostPaths != nil {
+			sdkVerStr := fmt.Sprintf("%d", ver)
+			if ver == AnySdkVersion {
+				sdkVerStr = "any" // a special keyword that means any SDK version
+			}
+			clcStr += fmt.Sprintf(" --host-context-for-sdk %s %s", sdkVerStr, strings.Join(hostClc, "#"))
+			clcStr += fmt.Sprintf(" --target-context-for-sdk %s %s", sdkVerStr, strings.Join(targetClc, "#"))
+			paths = append(paths, hostPaths...)
+		}
+	}
+
+	return clcStr, paths
+}
+
 func dexpreoptCommand(ctx android.PathContext, globalSoong *GlobalSoongConfig, global *GlobalConfig,
 	module *ModuleConfig, rule *android.RuleBuilder, archIdx int, classLoaderContexts classLoaderContextMap,
 	profile android.WritablePath, appImage bool, generateDM bool) {
@@ -422,20 +501,11 @@
 		}
 
 		// Generate command that saves host and target class loader context in shell variables.
+		clc, paths := computeClassLoaderContext(ctx, classLoaderContexts)
 		cmd := rule.Command().
 			Text(`eval "$(`).Tool(globalSoong.ConstructContext).
-			Text(` --target-sdk-version ${target_sdk_version}`)
-		for _, ver := range android.SortedIntKeys(classLoaderContexts) {
-			if clc := classLoaderContexts.getValue(ver); len(clc.Host) > 0 {
-				verString := fmt.Sprintf("%d", ver)
-				if ver == AnySdkVersion {
-					verString = "any" // a special keyword that means any SDK version
-				}
-				cmd.Textf(`--host-classpath-for-sdk %s %s`, verString, strings.Join(clc.Host.Strings(), ":")).
-					Implicits(clc.Host).
-					Textf(`--target-classpath-for-sdk %s %s`, verString, strings.Join(clc.Target, ":"))
-			}
-		}
+			Text(` --target-sdk-version ${target_sdk_version}`).
+			Text(clc).Implicits(paths)
 		cmd.Text(`)"`)
 	} else {
 		// Pass special class loader context to skip the classpath and collision check.