Somehow this wasn't committed last time. M_CLOBBERS_PRED is gone.

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

diff --git a/lib/Archive/Archive.cpp b/lib/Archive/Archive.cpp
index 66b9d703a0da117537d3ceae4cadc68000e55180..b7e7106ae6fe70abeba8a406996824059008ce1a 100644 (file)
--- a/lib/Archive/Archive.cpp
+++ b/lib/Archive/Archive.cpp
@@ -13,9 +13,11 @@
 //===----------------------------------------------------------------------===//
 
 #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"
-
 using namespace llvm;
 
 // getMemberSize - compute the actual physical size of the file member as seen
@@ -61,8 +63,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;
 
@@ -104,40 +111,45 @@ void ArchiveMember::replaceWith(const sys::Path& newFile) {
     flags &= ~HasLongFilenameFlag;
 
   // Get the signature and status info
-  std::string magic;
   const char* signature = (const char*) data;
+  std::string magic;
   if (!signature) {
     path.getMagicNumber(magic,4);
     signature = magic.c_str();
-    path.getStatusInfo(info);
+    std::string err;
+    const sys::FileStatus *FSinfo = path.getFileStatus(false, ErrMsg);
+    if (FSinfo)
+      info = *FSinfo;
+    else
+      return true;
   }
 
   // Determine what kind of file it is
   switch (sys::IdentifyFileType(signature,4)) {
-    case sys::BytecodeFileType:
-      flags |= BytecodeFlag;
-      break;
-    case sys::CompressedBytecodeFileType:
-      flags |= CompressedBytecodeFlag;
-      flags &= ~CompressedFlag;
-      break;
     default:
-      flags &= ~(BytecodeFlag|CompressedBytecodeFlag);
+      flags &= ~BitcodeFlag;
       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)
   : archPath(filename), members(), mapfile(0), base(0), symTab(), strtab(),
-    symTabSize(0), firstFileOffset(0), modules(), foreignST(0)
+    symTabSize(0), firstFileOffset(0), modules(), foreignST(0) {
+}
+
+bool
+Archive::mapToMemory(std::string* ErrMsg)
 {
-  if (map) {
-    mapfile = new sys::MappedFile(filename);
-    base = (char*) mapfile->map();
-  }
+  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() {
@@ -175,3 +187,78 @@ 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 bitcode
+bool llvm::GetBitcodeSymbols(const sys::Path& fName,
+                             std::vector<std::string>& symbols,
+                             std::string* ErrMsg) {
+  std::auto_ptr<MemoryBuffer> Buffer(
+                       MemoryBuffer::getFileOrSTDIN(&fName.toString()[0],
+                                                    fName.toString().size()));
+  if (!Buffer.get()) {
+    if (ErrMsg) *ErrMsg = "Could not open file '" + fName.toString() + "'";
+    return true;
+  }
+  
+  ModuleProvider *MP = getBitcodeModuleProvider(Buffer.get(), 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::GetBitcodeSymbols(const unsigned char *BufPtr, unsigned Length,
+                        const std::string& ModuleID,
+                        std::vector<std::string>& symbols,
+                        std::string* ErrMsg) {
+  // Get the module provider
+  MemoryBuffer *Buffer =MemoryBuffer::getNewMemBuffer(Length, ModuleID.c_str());
+  memcpy((char*)Buffer->getBufferStart(), BufPtr, Length);
+  
+  ModuleProvider *MP = getBitcodeModuleProvider(Buffer, ErrMsg);
+  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;
+}