Kill ModuleProvider and ghost linkage by inverting the relationship between

Modules and ModuleProviders. Because the "ModuleProvider" simply materializes
GlobalValues now, and doesn't provide modules, it's renamed to
"GVMaterializer". Code that used to need a ModuleProvider to materialize
Functions can now materialize the Functions directly. Functions no longer use a
magic linkage to record that they're materializable; they simply ask the
GVMaterializer.

Because the C ABI must never change, we can't remove LLVMModuleProviderRef or
the functions that refer to it. Instead, because Module now exposes the same
functionality ModuleProvider used to, we store a Module* in any
LLVMModuleProviderRef and translate in the wrapper methods.  The bindings to
other languages still use the ModuleProvider concept.  It would probably be
worth some time to update them to follow the C++ more closely, but I don't
intend to do it.

Fixes http://llvm.org/PR5737 and http://llvm.org/PR5735.


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

1 files changed, 14 insertions, 29 deletions

diff --git a/lib/Archive/Archive.cpp b/lib/Archive/Archive.cpp
index 00778d9983..f4f8a4349e 100644
--- a/lib/Archive/Archive.cpp
+++ b/lib/Archive/Archive.cpp
@@ -14,7 +14,6 @@
 
 #include "ArchiveInternals.h"
 #include "llvm/Bitcode/ReaderWriter.h"
-#include "llvm/ModuleProvider.h"
 #include "llvm/Module.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/System/Process.h"
@@ -173,8 +172,8 @@ void Archive::cleanUpMemory() {
     foreignST = 0;
   }
   
-  // Delete any ModuleProviders and ArchiveMember's we've allocated as a result
-  // of symbol table searches.
+  // Delete any Modules and ArchiveMember's we've allocated as a result of
+  // symbol table searches.
   for (ModuleMap::iterator I=modules.begin(), E=modules.end(); I != E; ++I ) {
     delete I->second.first;
     delete I->second.second;
@@ -221,51 +220,37 @@ bool llvm::GetBitcodeSymbols(const sys::Path& fName,
     return true;
   }
   
-  ModuleProvider *MP = getBitcodeModuleProvider(Buffer.get(), Context, ErrMsg);
-  if (!MP)
+  Module *M = ParseBitcodeFile(Buffer.get(), Context, ErrMsg);
+  if (!M)
     return true;
   
-  // Get the module from the provider
-  Module* M = MP->materializeModule();
-  if (M == 0) {
-    delete MP;
-    return true;
-  }
-  
   // Get the symbols
   getSymbols(M, symbols);
   
   // Done with the module.
-  delete MP;
+  delete M;
   return true;
 }
 
-ModuleProvider*
+Module*
 llvm::GetBitcodeSymbols(const unsigned char *BufPtr, unsigned Length,
                         const std::string& ModuleID,
                         LLVMContext& Context,
                         std::vector<std::string>& symbols,
                         std::string* ErrMsg) {
-  // Get the module provider
-  MemoryBuffer *Buffer =MemoryBuffer::getNewMemBuffer(Length, ModuleID.c_str());
+  // Get the module.
+  std::auto_ptr<MemoryBuffer> Buffer(
+    MemoryBuffer::getNewMemBuffer(Length, ModuleID.c_str()));
   memcpy((char*)Buffer->getBufferStart(), BufPtr, Length);
   
-  ModuleProvider *MP = getBitcodeModuleProvider(Buffer, Context, ErrMsg);
-  if (!MP)
+  Module *M = ParseBitcodeFile(Buffer.get(), Context, ErrMsg);
+  if (!M)
     return 0;
   
-  // Get the module from the provider
-  Module* M = MP->materializeModule();
-  if (M == 0) {
-    delete MP;
-    return 0;
-  }
-  
   // Get the symbols
   getSymbols(M, symbols);
   
-  // Done with the module. Note that ModuleProvider will delete the
-  // Module when it is deleted. Also note that its the caller's responsibility
-  // to delete the ModuleProvider.
-  return MP;
+  // Done with the module. Note that it's the caller's responsibility to delete
+  // the Module.
+  return M;
 }