For PR789:

[oota-llvm.git] / lib / Archive / Archive.cpp

diff --git a/lib/Archive/Archive.cpp b/lib/Archive/Archive.cpp
index d5b56ca85e292e255581fd91e2c0f4813b753160..f9fa80748bcc8360b41185eb000f5170ee1f6868 100644 (file)
--- a/lib/Archive/Archive.cpp
+++ b/lib/Archive/Archive.cpp
@@ -14,8 +14,9 @@
 
 #include "ArchiveInternals.h"
 #include "llvm/ModuleProvider.h"
+#include "llvm/Module.h"
+#include "llvm/Bytecode/Reader.h"
 #include "llvm/System/Process.h"
-
 using namespace llvm;
 
 // getMemberSize - compute the actual physical size of the file member as seen
@@ -61,8 +62,13 @@ ArchiveMember::ArchiveMember(Archive* PAR)
 // This method allows an ArchiveMember to be replaced with the data for a
 // different file, presumably as an update to the member. It also makes sure
 // the flags are reset correctly.
-void ArchiveMember::replaceWith(const sys::Path& newFile) {
-  assert(newFile.exists() && "Can't replace with a non-existent file");
+bool ArchiveMember::replaceWith(const sys::Path& newFile, std::string* ErrMsg) {
+  if (!newFile.exists()) {
+    if (ErrMsg) 
+      *ErrMsg = "Can not replace an archive member with a non-existent file";
+    return true;
+  }
+
   data = 0;
   path = newFile;
 
@@ -110,8 +116,11 @@ void ArchiveMember::replaceWith(const sys::Path& newFile) {
     path.getMagicNumber(magic,4);
     signature = magic.c_str();
     std::string err;
-    if (path.getFileStatus(info, &err))
-      throw err;
+    const sys::FileStatus *FSinfo = path.getFileStatus(false, ErrMsg);
+    if (FSinfo)
+      info = *FSinfo;
+    else
+      return true;
   }
 
   // Determine what kind of file it is
@@ -127,23 +136,27 @@ void ArchiveMember::replaceWith(const sys::Path& newFile) {
       flags &= ~(BytecodeFlag|CompressedBytecodeFlag);
       break;
   }
+  return false;
 }
 
 // Archive constructor - this is the only constructor that gets used for the
 // Archive class. Everything else (default,copy) is deprecated. This just
 // initializes and maps the file into memory, if requested.
-Archive::Archive(const sys::Path& filename, bool map )
+Archive::Archive(const sys::Path& filename, BCDecompressor_t *BCDC)
   : archPath(filename), members(), mapfile(0), base(0), symTab(), strtab(),
-    symTabSize(0), firstFileOffset(0), modules(), foreignST(0)
+    symTabSize(0), firstFileOffset(0), modules(), foreignST(0), 
+    Decompressor(BCDC) {
+}
+
+bool
+Archive::mapToMemory(std::string* ErrMsg)
 {
-  if (map) {
-    std::string ErrMsg;
-    mapfile = new sys::MappedFile();
-    if (mapfile->open(filename, sys::MappedFile::READ_ACCESS, &ErrMsg))
-      throw ErrMsg;
-    if (!(base = (char*) mapfile->map(&ErrMsg)))
-      throw ErrMsg;
-  }
+  mapfile = new sys::MappedFile();
+  if (mapfile->open(archPath, sys::MappedFile::READ_ACCESS, ErrMsg))
+    return true;
+  if (!(base = (char*) mapfile->map(ErrMsg)))
+    return true;
+  return false;
 }
 
 void Archive::cleanUpMemory() {
@@ -181,3 +194,70 @@ Archive::~Archive() {
   cleanUpMemory();
 }
 
+
+
+static void getSymbols(Module*M, std::vector<std::string>& symbols) {
+  // Loop over global variables
+  for (Module::global_iterator GI = M->global_begin(), GE=M->global_end(); GI != GE; ++GI)
+    if (!GI->isDeclaration() && !GI->hasInternalLinkage())
+      if (!GI->getName().empty())
+        symbols.push_back(GI->getName());
+  
+  // Loop over functions.
+  for (Module::iterator FI = M->begin(), FE = M->end(); FI != FE; ++FI)
+    if (!FI->isDeclaration() && !FI->hasInternalLinkage())
+      if (!FI->getName().empty())
+        symbols.push_back(FI->getName());
+}
+
+// Get just the externally visible defined symbols from the bytecode
+bool llvm::GetBytecodeSymbols(const sys::Path& fName,
+                              std::vector<std::string>& symbols,
+                              BCDecompressor_t *BCDC,
+                              std::string* ErrMsg) {
+  ModuleProvider *MP = getBytecodeModuleProvider(fName.toString(), BCDC,ErrMsg);
+  if (!MP)
+    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;
+  return true;
+}
+
+ModuleProvider*
+llvm::GetBytecodeSymbols(const unsigned char*Buffer, unsigned Length,
+                         const std::string& ModuleID,
+                         std::vector<std::string>& symbols,
+                         BCDecompressor_t *BCDC,
+                         std::string* ErrMsg) {
+  // Get the module provider
+  ModuleProvider* MP = 
+  getBytecodeBufferModuleProvider(Buffer, Length, ModuleID, BCDC, ErrMsg, 0);
+  if (!MP)
+    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;
+}