Merge topic 'pch-ios-multi-arch'

f593b354da PCH: Add support for multi architecture iOS projects

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !4561

1 files changed, 156 insertions, 122 deletions

diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index a80bc7c..6227f81 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -1520,16 +1520,17 @@ void cmLocalGenerator::GetTargetFlags(
 void cmLocalGenerator::GetTargetCompileFlags(cmGeneratorTarget* target,
                                              std::string const& config,
                                              std::string const& lang,
-                                             std::string& flags)
+                                             std::string& flags,
+                                             std::string const& arch)
 {
   std::vector<BT<std::string>> tmpFlags =
-    this->GetTargetCompileFlags(target, config, lang);
+    this->GetTargetCompileFlags(target, config, lang, arch);
   this->AppendFlags(flags, tmpFlags);
 }
 
 std::vector<BT<std::string>> cmLocalGenerator::GetTargetCompileFlags(
   cmGeneratorTarget* target, std::string const& config,
-  std::string const& lang)
+  std::string const& lang, std::string const& arch)
 {
   std::vector<BT<std::string>> flags;
   std::string compileFlags;
@@ -1543,7 +1544,7 @@ std::vector<BT<std::string>> cmLocalGenerator::GetTargetCompileFlags(
     this->AppendFeatureOptions(compileFlags, lang, "IPO");
   }
 
-  this->AddArchitectureFlags(compileFlags, target, lang, config);
+  this->AddArchitectureFlags(compileFlags, target, lang, config, arch);
 
   if (lang == "Fortran") {
     this->AppendFlags(compileFlags,
@@ -1771,7 +1772,8 @@ std::string cmLocalGenerator::GetLinkLibsCMP0065(
 void cmLocalGenerator::AddArchitectureFlags(std::string& flags,
                                             cmGeneratorTarget const* target,
                                             const std::string& lang,
-                                            const std::string& config)
+                                            const std::string& config,
+                                            const std::string& filterArch)
 {
   // Only add Apple specific flags on Apple platforms
   if (this->Makefile->IsOn("APPLE") && this->EmitUniversalBinaryFlags) {
@@ -1780,8 +1782,10 @@ void cmLocalGenerator::AddArchitectureFlags(std::string& flags,
     if (!archs.empty() && !lang.empty() &&
         (lang[0] == 'C' || lang[0] == 'F' || lang[0] == 'O')) {
       for (std::string const& arch : archs) {
-        flags += " -arch ";
-        flags += arch;
+        if (filterArch.empty() || filterArch == arch) {
+          flags += " -arch ";
+          flags += arch;
+        }
       }
     }
 
@@ -1804,10 +1808,12 @@ void cmLocalGenerator::AddArchitectureFlags(std::string& flags,
           if (arch_sysroots[i].empty()) {
             continue;
           }
-          flags += " -Xarch_" + archs[i] + " ";
-          // Combine sysroot flag and path to work with -Xarch
-          std::string arch_sysroot = sysrootFlag + arch_sysroots[i];
-          flags += this->ConvertToOutputFormat(arch_sysroot, SHELL);
+          if (filterArch.empty() || filterArch == archs[i]) {
+            flags += " -Xarch_" + archs[i] + " ";
+            // Combine sysroot flag and path to work with -Xarch
+            std::string arch_sysroot = sysrootFlag + arch_sysroots[i];
+            flags += this->ConvertToOutputFormat(arch_sysroot, SHELL);
+          }
         }
       } else if (sysroot && *sysroot) {
         flags += " ";
@@ -2446,146 +2452,174 @@ void cmLocalGenerator::AddPchDependencies(cmGeneratorTarget* target)
         continue;
       }
 
-      const std::string pchSource = target->GetPchSource(config, lang);
-      const std::string pchHeader = target->GetPchHeader(config, lang);
-
-      if (pchSource.empty() || pchHeader.empty()) {
-        continue;
+      std::vector<std::string> architectures;
+      if (!this->GetGlobalGenerator()->IsXcode()) {
+        target->GetAppleArchs(config, architectures);
       }
+      if (architectures.empty()) {
+        architectures.emplace_back();
+      } else {
+        std::string useMultiArchPch;
+        for (const std::string& arch : architectures) {
+          const std::string pchHeader =
+            target->GetPchHeader(config, lang, arch);
+          if (!pchHeader.empty()) {
+            useMultiArchPch = cmStrCat(useMultiArchPch, ";-Xarch_", arch,
+                                       ";-include", pchHeader);
+          }
+        }
 
-      const std::string pchExtension =
-        this->Makefile->GetSafeDefinition("CMAKE_PCH_EXTENSION");
-
-      if (pchExtension.empty()) {
-        continue;
+        if (!useMultiArchPch.empty()) {
+          target->Target->SetProperty(
+            cmStrCat(lang, "_COMPILE_OPTIONS_USE_PCH"), useMultiArchPch);
+        }
       }
 
-      const char* pchReuseFrom =
-        target->GetProperty("PRECOMPILE_HEADERS_REUSE_FROM");
+      for (const std::string& arch : architectures) {
+        const std::string pchSource = target->GetPchSource(config, lang, arch);
+        const std::string pchHeader = target->GetPchHeader(config, lang, arch);
 
-      auto pch_sf = this->Makefile->GetOrCreateSource(
-        pchSource, false, cmSourceFileLocationKind::Known);
+        if (pchSource.empty() || pchHeader.empty()) {
+          continue;
+        }
 
-      if (!this->GetGlobalGenerator()->IsXcode()) {
-        if (!pchReuseFrom) {
-          target->AddSource(pchSource, true);
+        const std::string pchExtension =
+          this->Makefile->GetSafeDefinition("CMAKE_PCH_EXTENSION");
+
+        if (pchExtension.empty()) {
+          continue;
         }
 
-        const std::string pchFile = target->GetPchFile(config, lang);
+        const char* pchReuseFrom =
+          target->GetProperty("PRECOMPILE_HEADERS_REUSE_FROM");
 
-        // Exclude the pch files from linking
-        if (this->Makefile->IsOn("CMAKE_LINK_PCH")) {
-          if (!pchReuseFrom) {
-            pch_sf->SetProperty("OBJECT_OUTPUTS", pchFile.c_str());
-          } else {
-            auto reuseTarget =
-              this->GlobalGenerator->FindGeneratorTarget(pchReuseFrom);
+        auto pch_sf = this->Makefile->GetOrCreateSource(
+          pchSource, false, cmSourceFileLocationKind::Known);
 
-            if (this->Makefile->IsOn("CMAKE_PCH_COPY_COMPILE_PDB")) {
+        if (!this->GetGlobalGenerator()->IsXcode()) {
+          if (!pchReuseFrom) {
+            target->AddSource(pchSource, true);
+          }
 
-              const std::string pdb_prefix =
-                this->GetGlobalGenerator()->IsMultiConfig()
-                ? cmStrCat(this->GlobalGenerator->GetCMakeCFGIntDir(), "/")
-                : "";
+          const std::string pchFile = target->GetPchFile(config, lang, arch);
 
-              const std::string target_compile_pdb_dir = cmStrCat(
-                target->GetLocalGenerator()->GetCurrentBinaryDirectory(), "/",
-                target->GetName(), ".dir/");
+          // Exclude the pch files from linking
+          if (this->Makefile->IsOn("CMAKE_LINK_PCH")) {
+            if (!pchReuseFrom) {
+              pch_sf->SetProperty("OBJECT_OUTPUTS", pchFile.c_str());
+            } else {
+              auto reuseTarget =
+                this->GlobalGenerator->FindGeneratorTarget(pchReuseFrom);
 
-              const std::string copy_script =
-                cmStrCat(target_compile_pdb_dir, "copy_idb_pdb.cmake");
-              cmGeneratedFileStream file(copy_script);
+              if (this->Makefile->IsOn("CMAKE_PCH_COPY_COMPILE_PDB")) {
 
-              file << "# CMake generated file\n";
-              for (auto extension : { ".pdb", ".idb" }) {
-                const std::string from_file =
-                  cmStrCat(reuseTarget->GetLocalGenerator()
-                             ->GetCurrentBinaryDirectory(),
-                           "/", pchReuseFrom, ".dir/${PDB_PREFIX}",
-                           pchReuseFrom, extension);
+                const std::string pdb_prefix =
+                  this->GetGlobalGenerator()->IsMultiConfig()
+                  ? cmStrCat(this->GlobalGenerator->GetCMakeCFGIntDir(), "/")
+                  : "";
 
-                const std::string to_dir = cmStrCat(
+                const std::string target_compile_pdb_dir = cmStrCat(
                   target->GetLocalGenerator()->GetCurrentBinaryDirectory(),
-                  "/", target->GetName(), ".dir/${PDB_PREFIX}");
+                  "/", target->GetName(), ".dir/");
 
-                const std::string to_file =
-                  cmStrCat(to_dir, pchReuseFrom, extension);
+                const std::string copy_script =
+                  cmStrCat(target_compile_pdb_dir, "copy_idb_pdb.cmake");
+                cmGeneratedFileStream file(copy_script);
 
-                std::string dest_file = to_file;
+                file << "# CMake generated file\n";
+                for (auto extension : { ".pdb", ".idb" }) {
+                  const std::string from_file =
+                    cmStrCat(reuseTarget->GetLocalGenerator()
+                               ->GetCurrentBinaryDirectory(),
+                             "/", pchReuseFrom, ".dir/${PDB_PREFIX}",
+                             pchReuseFrom, extension);
 
-                const std::string prefix = target->GetSafeProperty("PREFIX");
-                if (!prefix.empty()) {
-                  dest_file =
-                    cmStrCat(to_dir, prefix, pchReuseFrom, extension);
-                }
+                  const std::string to_dir = cmStrCat(
+                    target->GetLocalGenerator()->GetCurrentBinaryDirectory(),
+                    "/", target->GetName(), ".dir/${PDB_PREFIX}");
 
-                file << "if (EXISTS \"" << from_file << "\" AND \""
-                     << from_file << "\" IS_NEWER_THAN \"" << dest_file
-                     << "\")\n";
-                file << "  file(COPY \"" << from_file << "\""
-                     << " DESTINATION \"" << to_dir << "\")\n";
-                if (!prefix.empty()) {
-                  file << "  file(REMOVE \"" << dest_file << "\")\n";
-                  file << "  file(RENAME \"" << to_file << "\" \"" << dest_file
+                  const std::string to_file =
+                    cmStrCat(to_dir, pchReuseFrom, extension);
+
+                  std::string dest_file = to_file;
+
+                  const std::string prefix = target->GetSafeProperty("PREFIX");
+                  if (!prefix.empty()) {
+                    dest_file =
+                      cmStrCat(to_dir, prefix, pchReuseFrom, extension);
+                  }
+
+                  file << "if (EXISTS \"" << from_file << "\" AND \""
+                       << from_file << "\" IS_NEWER_THAN \"" << dest_file
                        << "\")\n";
+                  file << "  file(COPY \"" << from_file << "\""
+                       << " DESTINATION \"" << to_dir << "\")\n";
+                  if (!prefix.empty()) {
+                    file << "  file(REMOVE \"" << dest_file << "\")\n";
+                    file << "  file(RENAME \"" << to_file << "\" \""
+                         << dest_file << "\")\n";
+                  }
+                  file << "endif()\n";
                 }
-                file << "endif()\n";
-              }
 
-              cmCustomCommandLines commandLines = cmMakeSingleCommandLine(
-                { cmSystemTools::GetCMakeCommand(),
-                  cmStrCat("-DPDB_PREFIX=", pdb_prefix), "-P", copy_script });
-
-              const std::string no_main_dependency;
-              const std::vector<std::string> no_deps;
-              const char* no_message = "";
-              const char* no_current_dir = nullptr;
-              std::vector<std::string> no_byproducts;
-
-              std::vector<std::string> outputs;
-              outputs.push_back(cmStrCat(target_compile_pdb_dir, pdb_prefix,
-                                         pchReuseFrom, ".pdb"));
-
-              if (this->GetGlobalGenerator()->IsVisualStudio()) {
-                this->AddCustomCommandToTarget(
-                  target->GetName(), outputs, no_deps, commandLines,
-                  cmCustomCommandType::PRE_BUILD, no_message, no_current_dir);
-              } else {
-                cmImplicitDependsList no_implicit_depends;
-                cmSourceFile* copy_rule = this->AddCustomCommandToOutput(
-                  outputs, no_byproducts, no_deps, no_main_dependency,
-                  no_implicit_depends, commandLines, no_message,
-                  no_current_dir);
-
-                if (copy_rule) {
-                  target->AddSource(copy_rule->ResolveFullPath());
+                cmCustomCommandLines commandLines = cmMakeSingleCommandLine(
+                  { cmSystemTools::GetCMakeCommand(),
+                    cmStrCat("-DPDB_PREFIX=", pdb_prefix), "-P",
+                    copy_script });
+
+                const std::string no_main_dependency;
+                const std::vector<std::string> no_deps;
+                const char* no_message = "";
+                const char* no_current_dir = nullptr;
+                std::vector<std::string> no_byproducts;
+
+                std::vector<std::string> outputs;
+                outputs.push_back(cmStrCat(target_compile_pdb_dir, pdb_prefix,
+                                           pchReuseFrom, ".pdb"));
+
+                if (this->GetGlobalGenerator()->IsVisualStudio()) {
+                  this->AddCustomCommandToTarget(
+                    target->GetName(), outputs, no_deps, commandLines,
+                    cmCustomCommandType::PRE_BUILD, no_message,
+                    no_current_dir);
+                } else {
+                  cmImplicitDependsList no_implicit_depends;
+                  cmSourceFile* copy_rule = this->AddCustomCommandToOutput(
+                    outputs, no_byproducts, no_deps, no_main_dependency,
+                    no_implicit_depends, commandLines, no_message,
+                    no_current_dir);
+
+                  if (copy_rule) {
+                    target->AddSource(copy_rule->ResolveFullPath());
+                  }
                 }
-              }
 
-              target->Target->SetProperty("COMPILE_PDB_OUTPUT_DIRECTORY",
-                                          target_compile_pdb_dir);
-            }
+                target->Target->SetProperty("COMPILE_PDB_OUTPUT_DIRECTORY",
+                                            target_compile_pdb_dir);
+              }
 
-            std::string pchSourceObj =
-              reuseTarget->GetPchFileObject(config, lang);
+              std::string pchSourceObj =
+                reuseTarget->GetPchFileObject(config, lang, arch);
 
-            // Link to the pch object file
-            target->Target->AppendProperty(
-              "LINK_FLAGS",
-              cmStrCat(" ", this->ConvertToOutputFormat(pchSourceObj, SHELL)),
-              true);
+              // Link to the pch object file
+              target->Target->AppendProperty(
+                "LINK_FLAGS",
+                cmStrCat(" ",
+                         this->ConvertToOutputFormat(pchSourceObj, SHELL)),
+                true);
+            }
+          } else {
+            pch_sf->SetProperty("PCH_EXTENSION", pchExtension.c_str());
           }
-        } else {
-          pch_sf->SetProperty("PCH_EXTENSION", pchExtension.c_str());
-        }
 
-        // Add pchHeader to source files, which will
-        // be grouped as "Precompile Header File"
-        auto pchHeader_sf = this->Makefile->GetOrCreateSource(
-          pchHeader, false, cmSourceFileLocationKind::Known);
-        std::string err;
-        pchHeader_sf->ResolveFullPath(&err);
-        target->AddSource(pchHeader);
+          // Add pchHeader to source files, which will
+          // be grouped as "Precompile Header File"
+          auto pchHeader_sf = this->Makefile->GetOrCreateSource(
+            pchHeader, false, cmSourceFileLocationKind::Known);
+          std::string err;
+          pchHeader_sf->ResolveFullPath(&err);
+          target->AddSource(pchHeader);
+        }
       }
     }
   }