Implement parsing, AST, (de-)serialization, and placeholder global

metadata for linking against the libraries/frameworks for imported
modules.

The module map language is extended with a new "link" directive that
specifies what library or framework to link against when a module is
imported, e.g.,

  link "clangAST"

or

  link framework "MyFramework"

Importing the corresponding module (or any of its submodules) will
eventually link against the named library/framework.

For now, I've added some placeholder global metadata that encodes the
imported libraries/frameworks, so that we can test that this
information gets through to the IR. The format of the data is still
under discussion.



git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@172437 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 80 insertions, 2 deletions

diff --git a/lib/CodeGen/CodeGenModule.cpp b/lib/CodeGen/CodeGenModule.cpp
index 0257ce23f6..da37e4982d 100644
--- a/lib/CodeGen/CodeGenModule.cpp
+++ b/lib/CodeGen/CodeGenModule.cpp
@@ -32,6 +32,7 @@
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/ConvertUTF.h"
 #include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/Module.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Frontend/CodeGenOptions.h"
@@ -172,7 +173,8 @@ void CodeGenModule::Release() {
   EmitCtorList(GlobalDtors, "llvm.global_dtors");
   EmitGlobalAnnotations();
   EmitLLVMUsed();
-
+  EmitLinkLibraries();
+  
   SimplifyPersonality();
 
   if (getCodeGenOpts().EmitDeclMetadata)
@@ -714,6 +716,24 @@ void CodeGenModule::EmitLLVMUsed() {
   GV->setSection("llvm.metadata");
 }
 
+void CodeGenModule::EmitLinkLibraries() {
+  // If there are no libraries to link against, do nothing.
+  if (LinkLibraries.empty())
+    return;
+
+  // Create metadata for each library we're linking against.
+  llvm::NamedMDNode *Metadata
+    = getModule().getOrInsertNamedMetadata("llvm.link.libraries");
+  for (unsigned I = 0, N = LinkLibraries.size(); I != N; ++I) {
+    llvm::Value *Args[2] = {
+      llvm::MDString::get(getLLVMContext(), LinkLibraries[I].Library),
+      llvm::ConstantInt::get(llvm::Type::getInt1Ty(getLLVMContext()),
+                             LinkLibraries[I].IsFramework)
+    };
+    Metadata->addOperand(llvm::MDNode::get(getLLVMContext(), Args));
+  }
+}
+
 void CodeGenModule::EmitDeferred() {
   // Emit code for any potentially referenced deferred decls.  Since a
   // previously unused static decl may become used during the generation of code
@@ -2681,7 +2701,6 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) {
   case Decl::TypeAliasTemplate:
   case Decl::NamespaceAlias:
   case Decl::Block:
-  case Decl::Import:
     break;
   case Decl::CXXConstructor:
     // Skip function templates
@@ -2762,6 +2781,53 @@ void CodeGenModule::EmitTopLevelDecl(Decl *D) {
     break;
   }
 
+  case Decl::Import: {
+    ImportDecl *Import = cast<ImportDecl>(D);
+
+    // Ignore import declarations that come from imported modules.
+    if (clang::Module *Owner = Import->getOwningModule()) {
+      if (getLangOpts().CurrentModule.empty() ||
+          Owner->getTopLevelModule()->Name == getLangOpts().CurrentModule)
+        break;
+    }
+
+    // Walk from this module up to its top-level module; we'll import all of
+    // these modules and their non-explicit child modules.
+    llvm::SmallVector<clang::Module *, 2> Stack;
+    for (clang::Module *Mod = Import->getImportedModule(); Mod;
+         Mod = Mod->Parent) {
+      if (!ImportedModules.insert(Mod))
+        break;
+      
+      Stack.push_back(Mod);
+    }
+
+    // Find all of the non-explicit submodules of the modules we've imported and
+    // import them.
+    while (!Stack.empty()) {
+      clang::Module *Mod = Stack.back();
+      Stack.pop_back();
+
+      // Add the link libraries for this module.
+      LinkLibraries.insert(LinkLibraries.end(),
+                           Mod->LinkLibraries.begin(),
+                           Mod->LinkLibraries.end());
+
+      // We've imported this module; now import any of its children that haven't
+      // already been imported.
+      for (clang::Module::submodule_iterator Sub = Mod->submodule_begin(),
+                                          SubEnd = Mod->submodule_end();
+           Sub != SubEnd; ++Sub) {
+        if ((*Sub)->IsExplicit)
+          continue;
+
+        if (ImportedModules.insert(*Sub))
+          Stack.push_back(*Sub);
+      }
+    }
+    break;
+ }
+
   default:
     // Make sure we handled everything we should, every other kind is a
     // non-top-level decl.  FIXME: Would be nice to have an isTopLevelDeclKind
diff --git a/lib/CodeGen/CodeGenModule.h b/lib/CodeGen/CodeGenModule.h
index 34fa19c010..0d644a748e 100644
--- a/lib/CodeGen/CodeGenModule.h
+++ b/lib/CodeGen/CodeGenModule.h
@@ -23,7 +23,9 @@
 #include "clang/AST/Mangle.h"
 #include "clang/Basic/ABI.h"
 #include "clang/Basic/LangOptions.h"
+#include "clang/Basic/Module.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/IR/Module.h"
@@ -66,6 +68,7 @@ namespace clang {
   class AnnotateAttr;
   class CXXDestructorDecl;
   class MangleBuffer;
+  class Module;
 
 namespace CodeGen {
 
@@ -313,6 +316,12 @@ class CodeGenModule : public CodeGenTypeCache {
   /// run on termination.
   std::vector<std::pair<llvm::WeakVH,llvm::Constant*> > CXXGlobalDtors;
 
+  /// \brief The complete set of modules that has been imported.
+  llvm::SetVector<clang::Module *> ImportedModules;
+
+  /// \brief The set of libraries to link against.
+  std::vector<clang::Module::LinkLibrary> LinkLibraries;
+
   /// @name Cache for Objective-C runtime types
   /// @{
 
@@ -989,6 +998,9 @@ private:
   /// references to global which may otherwise be optimized out.
   void EmitLLVMUsed();
 
+  /// \brief Emit the set of libraries to link against.
+  void EmitLinkLibraries();
+
   void EmitDeclMetadata();
 
   /// EmitCoverageFile - Emit the llvm.gcov metadata used to tell LLVM where