---

yaml
---
r: 346070
b: refs/heads/master
c: 4e9e3a1
h: refs/heads/master

Author: swift-ci

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 3a211233113543229b4ad546c8fc368090216e48
+refs/heads/master: 4e9e3a1a3ee2b99727d876cf7b28af42af9f1561
 refs/heads/master-next: 203b3026584ecad859eb328b2e12490099409cd5
 refs/tags/osx-passed: b6b74147ef8a386f532cf9357a1bde006e552c54
 refs/tags/swift-2.2-SNAPSHOT-2015-12-01-a: 6bb18e013c2284f2b45f5f84f2df2887dc0f7dea

trunk/include/swift/AST/DiagnosticsFrontend.def

@@ -276,6 +276,9 @@ ERROR(missing_dependency_of_parseable_module_interface,none,
 ERROR(error_extracting_dependencies_from_cached_module,none,
       "error extracting dependencies from cached module '%0'",
       (StringRef))
+ERROR(unknown_forced_module_loading_mode,none,
+      "unknown value for SWIFT_FORCE_MODULE_LOADING variable: '%0'",
+      (StringRef))
 
 #ifndef DIAG_NO_UNDEF
 # if defined(DIAG)

trunk/include/swift/Frontend/ParseableInterfaceSupport.h

@@ -61,8 +61,9 @@ getModuleCachePathFromClang(const clang::CompilerInstance &Instance);
 /// directory, and loading the serialized .swiftmodules from there.
 class ParseableInterfaceModuleLoader : public SerializedModuleLoaderBase {
   explicit ParseableInterfaceModuleLoader(ASTContext &ctx, StringRef cacheDir,
-                                          DependencyTracker *tracker)
-    : SerializedModuleLoaderBase(ctx, tracker),
+                                          DependencyTracker *tracker,
+                                          ModuleLoadingMode loadMode)
+    : SerializedModuleLoaderBase(ctx, tracker, loadMode),
       CacheDir(cacheDir)
   {}
 
@@ -83,9 +84,10 @@ class ParseableInterfaceModuleLoader : public SerializedModuleLoaderBase {
 public:
   static std::unique_ptr<ParseableInterfaceModuleLoader>
   create(ASTContext &ctx, StringRef cacheDir,
-         DependencyTracker *tracker = nullptr) {
+         DependencyTracker *tracker,
+         ModuleLoadingMode loadMode) {
     return std::unique_ptr<ParseableInterfaceModuleLoader>(
-        new ParseableInterfaceModuleLoader(ctx, cacheDir, tracker));
+        new ParseableInterfaceModuleLoader(ctx, cacheDir, tracker, loadMode));
   }
 };
 

trunk/include/swift/Serialization/SerializedModuleLoader.h

@@ -20,6 +20,15 @@
 namespace swift {
 class ModuleFile;
 
+/// Spceifies how to load modules when both a parseable interface and serialized
+/// AST are present, or whether to disallow one format or the other altogether.
+enum class ModuleLoadingMode {
+  PreferParseable,
+  PreferSerialized,
+  OnlyParseable,
+  OnlySerialized
+};
+
 /// Common functionality shared between \c SerializedModuleLoader and
 /// \c ParseableInterfaceModuleLoader.
 class SerializedModuleLoaderBase : public ModuleLoader {
@@ -32,7 +41,9 @@ class SerializedModuleLoaderBase : public ModuleLoader {
 protected:
   llvm::StringMap<std::unique_ptr<llvm::MemoryBuffer>> MemoryBuffers;
   ASTContext &Ctx;
-  SerializedModuleLoaderBase(ASTContext &ctx, DependencyTracker *tracker);
+  ModuleLoadingMode LoadMode;
+  SerializedModuleLoaderBase(ASTContext &ctx, DependencyTracker *tracker,
+                             ModuleLoadingMode LoadMode);
 
   using AccessPathElem = std::pair<Identifier, SourceLoc>;
   bool findModule(AccessPathElem moduleID,
@@ -47,6 +58,18 @@ class SerializedModuleLoaderBase : public ModuleLoader {
                   std::unique_ptr<llvm::MemoryBuffer> *ModuleDocBuffer,
                   llvm::SmallVectorImpl<char> &Scratch);
 
+  /// If the module loader subclass knows that all options have been tried for
+  /// loading an architecture-specific file out of a swiftmodule bundle, try
+  /// to list the architectures that \e are present.
+  ///
+  /// \returns true if an error diagnostic was emitted
+  virtual bool maybeDiagnoseArchitectureMismatch(SourceLoc sourceLocation,
+                                                 StringRef moduleName,
+                                                 StringRef archName,
+                                                 StringRef directoryPath) {
+    return false;
+  }
+
 public:
   virtual ~SerializedModuleLoaderBase();
   SerializedModuleLoaderBase(const SerializedModuleLoaderBase &) = delete;
@@ -100,10 +123,23 @@ class SerializedModuleLoaderBase : public ModuleLoader {
 /// Imports serialized Swift modules into an ASTContext.
 class SerializedModuleLoader : public SerializedModuleLoaderBase {
 
-  SerializedModuleLoader(ASTContext &ctx, DependencyTracker *tracker)
-    : SerializedModuleLoaderBase(ctx, tracker)
+  SerializedModuleLoader(ASTContext &ctx, DependencyTracker *tracker,
+                         ModuleLoadingMode loadMode)
+    : SerializedModuleLoaderBase(ctx, tracker, loadMode)
   {}
 
+  std::error_code
+  openModuleFiles(StringRef DirName, StringRef ModuleFilename,
+                  StringRef ModuleDocFilename,
+                  std::unique_ptr<llvm::MemoryBuffer> *ModuleBuffer,
+                  std::unique_ptr<llvm::MemoryBuffer> *ModuleDocBuffer,
+                  llvm::SmallVectorImpl<char> &Scratch) override;
+
+  bool maybeDiagnoseArchitectureMismatch(SourceLoc sourceLocation,
+                                         StringRef moduleName,
+                                         StringRef archName,
+                                         StringRef directoryPath) override;
+
 public:
   virtual ~SerializedModuleLoader();
 
@@ -120,9 +156,10 @@ class SerializedModuleLoader : public SerializedModuleLoaderBase {
   /// Create a new importer that can load serialized Swift modules
   /// into the given ASTContext.
   static std::unique_ptr<SerializedModuleLoader>
-  create(ASTContext &ctx, DependencyTracker *tracker = nullptr) {
+  create(ASTContext &ctx, DependencyTracker *tracker = nullptr,
+         ModuleLoadingMode loadMode = ModuleLoadingMode::PreferSerialized) {
     return std::unique_ptr<SerializedModuleLoader>{
-      new SerializedModuleLoader(ctx, tracker)
+      new SerializedModuleLoader(ctx, tracker, loadMode)
     };
   }
 };

trunk/lib/Frontend/Frontend.cpp

@@ -36,6 +36,7 @@
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Path.h"
+#include "llvm/Support/Process.h"
 
 using namespace swift;
 
@@ -288,33 +289,54 @@ bool CompilerInstance::setUpModuleLoaders() {
                                                   enableResilience,
                                                   getDependencyTracker()));
   }
-  {
-    auto SML = SerializedModuleLoader::create(*Context, getDependencyTracker());
-    this->SML = SML.get();
-    Context->addModuleLoader(std::move(SML));
+  auto MLM = ModuleLoadingMode::OnlySerialized;
+  if (Invocation.getFrontendOptions().EnableParseableModuleInterface) {
+    MLM = ModuleLoadingMode::PreferSerialized;
   }
-  std::string ModuleCachePath;
-  {
-    // Wire up the Clang importer. If the user has specified an SDK, use it.
-    // Otherwise, we just keep it around as our interface to Clang's ABI
-    // knowledge.
-    auto clangImporter =
-        ClangImporter::create(*Context, Invocation.getClangImporterOptions(),
-                              Invocation.getPCHHash(), getDependencyTracker());
-    if (!clangImporter) {
-      Diagnostics.diagnose(SourceLoc(), diag::error_clang_importer_create_fail);
+  if (auto forceModuleLoadingMode =
+      llvm::sys::Process::GetEnv("SWIFT_FORCE_MODULE_LOADING")) {
+    if (*forceModuleLoadingMode == "prefer-parseable")
+      MLM = ModuleLoadingMode::PreferParseable;
+    else if (*forceModuleLoadingMode == "prefer-serialized")
+      MLM = ModuleLoadingMode::PreferSerialized;
+    else if (*forceModuleLoadingMode == "only-parseable")
+      MLM = ModuleLoadingMode::OnlyParseable;
+    else if (*forceModuleLoadingMode == "only-serialized")
+      MLM = ModuleLoadingMode::OnlySerialized;
+    else {
+      Diagnostics.diagnose(SourceLoc(),
+                           diag::unknown_forced_module_loading_mode,
+                           *forceModuleLoadingMode);
       return true;
     }
-    auto const &Clang = clangImporter->getClangInstance();
-    ModuleCachePath = getModuleCachePathFromClang(Clang);
-    Context->addModuleLoader(std::move(clangImporter), /*isClang*/ true);
   }
-  if (Invocation.getFrontendOptions().EnableParseableModuleInterface) {
+
+  std::unique_ptr<SerializedModuleLoader> SML =
+    SerializedModuleLoader::create(*Context, getDependencyTracker(), MLM);
+  this->SML = SML.get();
+
+  // Wire up the Clang importer. If the user has specified an SDK, use it.
+  // Otherwise, we just keep it around as our interface to Clang's ABI
+  // knowledge.
+  std::unique_ptr<ClangImporter> clangImporter =
+    ClangImporter::create(*Context, Invocation.getClangImporterOptions(),
+                          Invocation.getPCHHash(), getDependencyTracker());
+  if (!clangImporter) {
+    Diagnostics.diagnose(SourceLoc(), diag::error_clang_importer_create_fail);
+    return true;
+  }
+
+  if (MLM != ModuleLoadingMode::OnlySerialized) {
+    auto const &Clang = clangImporter->getClangInstance();
+    std::string ModuleCachePath = getModuleCachePathFromClang(Clang);
     auto PIML = ParseableInterfaceModuleLoader::create(*Context,
                                                        ModuleCachePath,
-                                                       getDependencyTracker());
+                                                       getDependencyTracker(),
+                                                       MLM);
     Context->addModuleLoader(std::move(PIML));
   }
+  Context->addModuleLoader(std::move(SML));
+  Context->addModuleLoader(std::move(clangImporter), /*isClang*/ true);
   return false;
 }
 

trunk/lib/Frontend/ParseableInterfaceSupport.cpp

@@ -279,6 +279,7 @@ static bool buildSwiftModuleFromSwiftInterface(
     StringRef ModuleCachePath, DependencyTracker *OuterTracker) {
   bool SubError = false;
   bool RunSuccess = llvm::CrashRecoveryContext().RunSafelyOnThread([&] {
+    (void)llvm::sys::fs::create_directory(ModuleCachePath);
 
     llvm::BumpPtrAllocator SubArgsAlloc;
     llvm::StringSaver SubArgSaver(SubArgsAlloc);
@@ -366,6 +367,17 @@ static bool buildSwiftModuleFromSwiftInterface(
   return !RunSuccess || SubError;
 }
 
+static bool serializedASTLooksValidOrCannotBeRead(clang::vfs::FileSystem &FS,
+                                                  StringRef ModPath) {
+  auto ModBuf = FS.getBufferForFile(ModPath, /*FileSize=*/-1,
+                                    /*RequiresNullTerminator=*/false);
+  if (!ModBuf)
+    return ModBuf.getError() != std::errc::no_such_file_or_directory;
+
+  auto VI = serialization::validateSerializedAST(ModBuf.get()->getBuffer());
+  return VI.status == serialization::Status::Valid;
+}
+
 /// Load a .swiftmodule associated with a .swiftinterface either from a
 /// cache or by converting it in a subordinate \c CompilerInstance, caching
 /// the results.
@@ -375,18 +387,39 @@ std::error_code ParseableInterfaceModuleLoader::openModuleFiles(
     std::unique_ptr<llvm::MemoryBuffer> *ModuleDocBuffer,
     llvm::SmallVectorImpl<char> &Scratch) {
 
+  // If running in OnlySerialized mode, ParseableInterfaceModuleLoader
+  // should not have been constructed at all.
+  assert(LoadMode != ModuleLoadingMode::OnlySerialized);
+
   auto &FS = *Ctx.SourceMgr.getFileSystem();
   auto &Diags = Ctx.Diags;
-  llvm::SmallString<128> InPath, OutPath;
+  llvm::SmallString<128> ModPath, InPath, OutPath;
 
   // First check to see if the .swiftinterface exists at all. Bail if not.
-  InPath = DirName;
-  llvm::sys::path::append(InPath, ModuleFilename);
+  ModPath = DirName;
+  llvm::sys::path::append(ModPath, ModuleFilename);
+
   auto Ext = file_types::getExtension(file_types::TY_SwiftParseableInterfaceFile);
+  InPath = ModPath;
   llvm::sys::path::replace_extension(InPath, Ext);
   if (!FS.exists(InPath))
     return std::make_error_code(std::errc::no_such_file_or_directory);
 
+  // Next, if we're in the load mode that prefers .swiftmodules, see if there's
+  // one here we can _likely_ load (validates OK). If so, bail early with
+  // errc::not_supported, so the next (serialized) loader in the chain will load
+  // it. Alternately, if there's a .swiftmodule present but we can't even read
+  // it (for whatever reason), we should let the other module loader diagnose
+  // it.
+  if (LoadMode == ModuleLoadingMode::PreferSerialized &&
+      serializedASTLooksValidOrCannotBeRead(FS, ModPath)) {
+    return std::make_error_code(std::errc::not_supported);
+  }
+
+  // At this point we're either in PreferParseable mode or there's no credible
+  // adjacent .swiftmodule so we'll go ahead and start trying to convert the
+  // .swiftinterface.
+
   // Set up a _potential_ sub-invocation to consume the .swiftinterface and emit
   // the .swiftmodule.
   CompilerInvocation SubInvocation;