eliminate lengths from record bodies
[oota-llvm.git] / lib / Linker / LinkArchives.cpp
index e115b93ad28b7f60d4ba69dc7b70369db62c6582..95ac1ab1fd9d6de45cb033f6f8ba53cc524ba60a 100644 (file)
 #include <set>
 using namespace llvm;
 
-/// GetAllDefinedSymbols - Modifies its parameter DefinedSymbols to contain the
-/// name of each externally-visible symbol defined in M.
-///
-static void
-GetAllDefinedSymbols(Module *M, std::set<std::string> &DefinedSymbols) {
-  for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
-    if (I->hasName() && !I->isExternal() && !I->hasInternalLinkage())
-      DefinedSymbols.insert(I->getName());
-  for (Module::global_iterator I = M->global_begin(), E = M->global_end();
-       I != E; ++I)
-    if (I->hasName() && !I->isExternal() && !I->hasInternalLinkage())
-      DefinedSymbols.insert(I->getName());
-}
-
 /// GetAllUndefinedSymbols - calculates the set of undefined symbols that still
 /// exist in an LLVM module. This is a bit tricky because there may be two
 /// symbols with the same name but different LLVM types that will be resolved to
@@ -57,24 +43,30 @@ GetAllUndefinedSymbols(Module *M, std::set<std::string> &UndefinedSymbols) {
   // If the program doesn't define a main, try pulling one in from a .a file.
   // This is needed for programs where the main function is defined in an
   // archive, such f2c'd programs.
-  Function *Main = M->getMainFunction();
-  if (Main == 0 || Main->isExternal())
+  Function *Main = M->getFunction("main");
+  if (Main == 0 || Main->isDeclaration())
     UndefinedSymbols.insert("main");
 
   for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
     if (I->hasName()) {
-      if (I->isExternal())
+      if (I->isDeclaration())
         UndefinedSymbols.insert(I->getName());
-      else if (!I->hasInternalLinkage())
+      else if (!I->hasInternalLinkage()) {
+        assert(!I->hasDLLImportLinkage()
+               && "Found dllimported non-external symbol!");
         DefinedSymbols.insert(I->getName());
+      }      
     }
   for (Module::global_iterator I = M->global_begin(), E = M->global_end();
        I != E; ++I)
     if (I->hasName()) {
-      if (I->isExternal())
+      if (I->isDeclaration())
         UndefinedSymbols.insert(I->getName());
-      else if (!I->hasInternalLinkage())
+      else if (!I->hasInternalLinkage()) {
+        assert(!I->hasDLLImportLinkage()
+               && "Found dllimported non-external symbol!");
         DefinedSymbols.insert(I->getName());
+      }      
     }
 
   // Prune out any defined symbols from the undefined symbols set...
@@ -96,7 +88,7 @@ GetAllUndefinedSymbols(Module *M, std::set<std::string> &UndefinedSymbols) {
 ///  TRUE  - An error occurred.
 ///  FALSE - No errors.
 bool
-Linker::LinkInArchive(const sys::Path &Filename) {
+Linker::LinkInArchive(const sys::Path &Filename, bool &is_native) {
 
   // Make sure this is an archive file we're dealing with
   if (!Filename.isArchive())
@@ -126,14 +118,23 @@ Linker::LinkInArchive(const sys::Path &Filename) {
   if (!arch)
     return error("Cannot read archive '" + Filename.toString() +
                  "': " + ErrMsg);
+  if (!arch->isBytecodeArchive()) {
+    is_native = true;
+    return false;
+  }
+  is_native = false;
 
   // Save a set of symbols that are not defined by the archive. Since we're
   // entering a loop, there's no point searching for these multiple times. This
   // variable is used to "set_subtract" from the set of undefined symbols.
   std::set<std::string> NotDefinedByArchive;
 
-  // While we are linking in object files, loop.
-  while (true) {
+  // Save the current set of undefined symbols, because we may have to make
+  // multiple passes over the archive:
+  std::set<std::string> CurrentlyUndefinedSymbols;
+
+  do {
+    CurrentlyUndefinedSymbols = UndefinedSymbols;
 
     // Find the modules we need to link into the target module
     std::set<ModuleProvider*> Modules;
@@ -157,17 +158,21 @@ Linker::LinkInArchive(const sys::Path &Filename) {
          I != E; ++I) {
 
       // Get the module we must link in.
-      std::auto_ptr<Module> AutoModule( (*I)->releaseModule() );
+      std::string moduleErrorMsg;
+      std::auto_ptr<Module> AutoModule((*I)->releaseModule( &moduleErrorMsg ));
       Module* aModule = AutoModule.get();
 
-      verbose("  Linking in module: " + aModule->getModuleIdentifier());
+      if (aModule != NULL) {
+        verbose("  Linking in module: " + aModule->getModuleIdentifier());
 
-      // Link it in
-      if (LinkInModule(aModule))
-        return error("Cannot link in module '" +
-                     aModule->getModuleIdentifier() + "': " + Error);
+        // Link it in
+        if (LinkInModule(aModule, &moduleErrorMsg)) {
+          return error("Cannot link in module '" +
+                       aModule->getModuleIdentifier() + "': " + moduleErrorMsg);
+        }
+      } 
     }
-
+    
     // Get the undefined symbols from the aggregate module. This recomputes the
     // symbols we still need after the new modules have been linked in.
     GetAllUndefinedSymbols(Composite, UndefinedSymbols);
@@ -183,7 +188,7 @@ Linker::LinkInArchive(const sys::Path &Filename) {
     // archive.
     if (UndefinedSymbols.empty())
       break;
-  }
+  } while (CurrentlyUndefinedSymbols != UndefinedSymbols);
 
   return false;
 }