--- dyld/dyld-1340/cache_builder/BuilderConfig.cpp
+++ dyld/dyld-1286.10/cache_builder/BuilderConfig.cpp
@@ -25,7 +25,6 @@
 #include "BuilderConfig.h"
 #include "BuilderOptions.h"
 #include "CodeSigningTypes.h"
-#include "Architecture.h"
 #include "Platform.h"
 
 #include "dyld_cache_config.h"
@@ -33,8 +32,8 @@
 #include <assert.h>
 
 using namespace cache_builder;
-
-using mach_o::Architecture;
+using dyld3::GradedArchs;
+
 using mach_o::Platform;
 
 //
@@ -44,11 +43,9 @@
 cache_builder::Logger::Logger(const BuilderOptions& options)
     : logPrefix(options.logPrefix)
 {
-    this->printTimers           = options.timePasses;
-    this->printStats            = options.stats;
-    this->printDebug            = options.debug;
-    this->printDebugIMPCaches   = options.debugIMPCaches;
-    this->printDebugCacheLayout = options.debugCacheLayout;
+    this->printTimers = options.timePasses;
+    this->printStats  = options.stats;
+    this->printDebug  = options.debug;
 }
 
 void cache_builder::Logger::log(const char* format, ...) const
@@ -68,31 +65,33 @@
 // MARK: --- cache_builder::Layout methods ---
 //
 
-static uint32_t defaultPageSize(Architecture arch)
-{
-    if ( arch.sameCpu(Architecture::x86_64) )
+static uint32_t defaultPageSize(std::string_view archName)
+{
+    if ( (archName == "x86_64") || (archName == "x86_64h") )
         return 4096;
     else
         return 16384;
 }
 
-static bool hasAuthRegion(Architecture arch)
-{
-    return arch == Architecture::arm64e;
-}
-
-static uint32_t supportsTPROMapping(Architecture arch)
-{
-    return !arch.sameCpu(Architecture::x86_64);
+static bool hasAuthRegion(std::string_view archName)
+{
+    return archName == "arm64e";
+}
+
+static uint32_t supportsTPROMapping(std::string_view archName)
+{
+    return (archName != "x86_64") && (archName != "x86_64h");
 }
 
 cache_builder::Layout::Layout(const BuilderOptions& options)
-: is64(options.arch.is64())
-    , hasAuthRegion(::hasAuthRegion(options.arch))
-    , tproIsInData(!::supportsTPROMapping(options.arch))
-    , pageSize(defaultPageSize(options.arch))
-{
-    if ( options.arch.sameCpu(Architecture::x86_64) ) {
+    : is64(options.archs.supports64())
+    , hasAuthRegion(::hasAuthRegion(options.archs.name()))
+    , tproIsInData(!::supportsTPROMapping(options.archs.name()))
+    , pageSize(defaultPageSize(options.archs.name()))
+{
+    std::string_view archName = options.archs.name();
+
+    if ( (archName == "x86_64") || (archName == "x86_64h") ) {
         // x86_64 uses discontiguous mappings
         this->discontiguous.emplace();
 
@@ -102,7 +101,9 @@
         // Everyone else uses contiguous mappings
         this->contiguous.emplace();
         this->contiguous->regionPadding = CacheVMSize(32_MB);
-        this->contiguous->subCacheTextDataLimit = CacheVMSize(2_GB);
+
+        // Note minus a little to account for rdar://146432183
+        this->contiguous->subCacheTextDataLimit = CacheVMSize(2_GB - 16_MB);
         this->contiguous->subCacheStubsLimit = CacheVMSize(110_MB);
 
         // Note we have 2 padding regions in total in a given TEXT/DATA/AUTH/... region
@@ -117,10 +118,10 @@
     };
     CacheLayout layout;
 
-    if ( options.arch.sameCpu(Architecture::x86_64) ) {
+    if ( (archName == "x86_64") || (archName == "x86_64h") ) {
         layout.baseAddress = X86_64_SHARED_REGION_START;
         layout.cacheSize = X86_64_SHARED_REGION_SIZE;
-    } else if ( options.arch.sameCpu(Architecture::arm64) ) {
+    } else if ( (archName == "arm64") || (archName == "arm64e") ) {
         layout.baseAddress = ARM64_SHARED_REGION_START;
 
         if ( options.isSimulator() ) {
@@ -134,7 +135,7 @@
         // caches putting 1.5GB of TEXT in the first cache region, this will ensure that
         // this 1.5GB of TEXT will stay in the same 2GB region.  <rdar://problem/49852839>
         cacheMaxSlide = 512_MB;
-    } else if ( options.arch == Architecture::arm64_32 ) {
+    } else if ( archName == "arm64_32" ) {
         layout.baseAddress = ARM64_32_SHARED_REGION_START;
         layout.cacheSize = 2_GB;
 
@@ -160,7 +161,8 @@
     if ( options.isSimulator() )
         return;
 
-    if ( options.arch.sameCpu(Architecture::x86_64) || (options.arch == Architecture::arm64) ) {
+    std::string_view archName = options.archs.name();
+    if ( (archName == "x86_64") || (archName == "x86_64h") || (archName == "arm64") ) {
         this->slideInfoFormat = SlideInfoFormat::v2;
 
         // 1 uint16_t per page
@@ -170,14 +172,14 @@
         this->slideInfoDeltaMask = 0x00FFFF0000000000ULL;
 
         // Only x86_64 needs a value add field on slide info V2
-        if ( options.arch.sameCpu(Architecture::x86_64) ) {
+        if ( (archName == "x86_64") || (archName == "x86_64h") ) {
             this->slideInfoValueAdd = layout.cacheBaseAddress;
         }
         else {
             this->slideInfoValueAdd = CacheVMAddress(0ULL);
         }
     }
-    else if ( options.arch == Architecture::arm64e ) {
+    else if ( archName == "arm64e" ) {
         // 1 uint16_t per page
         this->slideInfoBytesPerDataPage = 2;
 
@@ -190,7 +192,7 @@
             this->slideInfoFormat = SlideInfoFormat::v3;
         }
     }
-    else if ( options.arch == Architecture::arm64_32 ) {
+    else if ( archName == "arm64_32" ) {
         this->slideInfoFormat = SlideInfoFormat::v1;
 
         // 128 bytes per page.  Enough for a bitmap with 1-bit entry per 32-bit location
@@ -213,19 +215,20 @@
     return cache_builder::CodeSign::Mode::onlySHA256;
 }
 
-static uint32_t codeSigningPageSize(Platform platform, Architecture arch)
-{
-    if ( (arch == Architecture::arm64e) || (arch == Architecture::arm64_32) )
+static uint32_t codeSigningPageSize(Platform platform, const GradedArchs& arch)
+{
+    std::string_view archName = arch.name();
+    if ( (archName == "arm64e") || (archName == "arm64_32") )
         return CS_PAGE_SIZE_16K;
 
     // arm64 on iOS is new enough for 16k pages, as is arm64 on macOS (ie the simulator)
-    if ( arch == Architecture::arm64 ) {
+    if ( archName == "arm64") {
         if ( platform.isSimulator() || (platform == Platform::iOS) )
             return CS_PAGE_SIZE_16K;
         return CS_PAGE_SIZE_4K;
     }
 
-    if ( arch.sameCpu(Architecture::x86_64) )
+    if ( (archName == "x86_64") || (archName == "x86_64h") )
         return CS_PAGE_SIZE_4K;
 
     // Unknown arch
@@ -234,7 +237,7 @@
 
 cache_builder::CodeSign::CodeSign(const BuilderOptions& options)
     : mode(platformCodeSigningDigestMode(options.platform))
-    , pageSize(codeSigningPageSize(options.platform, options.arch))
+    , pageSize(codeSigningPageSize(options.platform, options.archs))
 {
 }