diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 2a6de41..6157a5d 100644
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -11,6 +11,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Bitcode/ReaderWriter.h"
 #include "BitcodeReader.h"
 #include "llvm/Bitcode/BitstreamReader.h"
 #include "llvm/Constants.h"
@@ -18,8 +19,14 @@
 #include "llvm/Module.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/MemoryBuffer.h"
 using namespace llvm;
 
+BitcodeReader::~BitcodeReader() {
+  delete Buffer;
+}
+
+
 /// ConvertToString - Convert a string from a record into an std::string, return
 /// true on failure.
 template<typename StrTy>
@@ -852,14 +859,14 @@
 }
 
 
-bool BitcodeReader::ParseBitcode(unsigned char *Buf, unsigned Length,
-                                 const std::string &ModuleID) {
+bool BitcodeReader::ParseBitcode() {
   TheModule = 0;
   
-  if (Length & 3)
+  if (Buffer->getBufferSize() & 3)
     return Error("Bitcode stream should be a multiple of 4 bytes in length");
   
-  BitstreamReader Stream(Buf, Buf+Length);
+  unsigned char *BufPtr = (unsigned char *)Buffer->getBufferStart();
+  BitstreamReader Stream(BufPtr, BufPtr+Buffer->getBufferSize());
   
   // Sniff for the signature.
   if (Stream.Read(8) != 'B' ||
@@ -882,7 +889,7 @@
     
     // We only know the MODULE subblock ID.
     if (BlockID == bitc::MODULE_BLOCK_ID) {
-      if (ParseModule(Stream, ModuleID))
+      if (ParseModule(Stream, Buffer->getBufferIdentifier()))
         return true;
     } else if (Stream.SkipBlock()) {
       return Error("Malformed block record");
@@ -891,3 +898,41 @@
   
   return false;
 }
+
+//===----------------------------------------------------------------------===//
+// External interface
+//===----------------------------------------------------------------------===//
+
+/// getBitcodeModuleProvider - lazy function-at-a-time loading from a file.
+///
+ModuleProvider *llvm::getBitcodeModuleProvider(MemoryBuffer *Buffer,
+                                               std::string *ErrMsg) {
+  BitcodeReader *R = new BitcodeReader(Buffer);
+  if (R->ParseBitcode()) {
+    if (ErrMsg)
+      *ErrMsg = R->getErrorString();
+    
+    // Don't let the BitcodeReader dtor delete 'Buffer'.
+    R->releaseMemoryBuffer();
+    delete R;
+    return 0;
+  }
+  return R;
+}
+
+/// ParseBitcodeFile - Read the specified bitcode file, returning the module.
+/// If an error occurs, return null and fill in *ErrMsg if non-null.
+Module *llvm::ParseBitcodeFile(MemoryBuffer *Buffer, std::string *ErrMsg){
+  BitcodeReader *R;
+  R = static_cast<BitcodeReader*>(getBitcodeModuleProvider(Buffer, ErrMsg));
+  if (!R) return 0;
+  
+  // Read the whole module, get a pointer to it, tell ModuleProvider not to
+  // delete it when its dtor is run.
+  Module *M = R->releaseModule(ErrMsg);
+  
+  // Don't let the BitcodeReader dtor delete 'Buffer'.
+  R->releaseMemoryBuffer();
+  delete R;
+  return M;
+}
diff --git a/lib/Bitcode/Reader/BitcodeReader.h b/lib/Bitcode/Reader/BitcodeReader.h
index 8e21134..0935c06 100644
--- a/lib/Bitcode/Reader/BitcodeReader.h
+++ b/lib/Bitcode/Reader/BitcodeReader.h
@@ -22,6 +22,7 @@
 
 namespace llvm {
   class BitstreamReader;
+  class MemoryBuffer;
   
 class BitcodeReaderValueList : public User {
   std::vector<Use> Uses;
@@ -57,6 +58,7 @@
   
 
 class BitcodeReader : public ModuleProvider {
+  MemoryBuffer *Buffer;
   const char *ErrorString;
   
   std::vector<PATypeHolder> TypeList;
@@ -64,10 +66,16 @@
   std::vector<std::pair<GlobalVariable*, unsigned> > GlobalInits;
   std::vector<std::pair<GlobalAlias*, unsigned> > AliasInits;
 public:
-  BitcodeReader() : ErrorString(0) {}
-  virtual ~BitcodeReader() {}
+  BitcodeReader(MemoryBuffer *buffer) : Buffer(buffer), ErrorString(0) {}
+  ~BitcodeReader();
   
-  virtual void FreeState() {}
+  
+  /// releaseMemoryBuffer - This causes the reader to completely forget about
+  /// the memory buffer it contains, which prevents the buffer from being
+  /// destroyed when it is deleted.
+  void releaseMemoryBuffer() {
+    Buffer = 0;
+  }
   
   virtual bool materializeFunction(Function *F, std::string *ErrInfo = 0) {
     // FIXME: TODO
@@ -89,8 +97,7 @@
   
   /// @brief Main interface to parsing a bitcode buffer.
   /// @returns true if an error occurred.
-  bool ParseBitcode(unsigned char *Buf, unsigned Length,
-                    const std::string &ModuleID);
+  bool ParseBitcode();
 private:
   const Type *getTypeByID(unsigned ID, bool isTypeTable = false);
   
diff --git a/lib/Bitcode/Reader/ReaderWrappers.cpp b/lib/Bitcode/Reader/ReaderWrappers.cpp
deleted file mode 100644
index 8bf81a2..0000000
--- a/lib/Bitcode/Reader/ReaderWrappers.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//===- ReaderWrappers.cpp - Parse bitcode from file or buffer -------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file was developed by Chris Lattner and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements loading and parsing a bitcode file and parsing a
-// module from a memory buffer.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Bitcode/ReaderWriter.h"
-#include "BitcodeReader.h"
-#include "llvm/System/MappedFile.h"
-using namespace llvm;
-
-//===----------------------------------------------------------------------===//
-// BitcodeFileReader - Read from an mmap'able file descriptor.
-
-namespace {
-  /// BitcodeFileReader - parses bitcode from a file.
-  ///
-  class BitcodeFileReader : public BitcodeReader {
-  private:
-    std::string Filename;
-    sys::MappedFile File;
-    
-    BitcodeFileReader(const BitcodeFileReader&); // DO NOT IMPLEMENT
-    void operator=(const BitcodeFileReader&); // DO NOT IMPLEMENT
-  public:
-    BitcodeFileReader(const std::string &FN) : Filename(FN) {}
-    bool Read(std::string *ErrMsg);
-    
-    void FreeState() {
-      BitcodeReader::FreeState();
-      File.close();
-    }
-  };
-}
-
-bool BitcodeFileReader::Read(std::string *ErrMsg) {
-  if (File.open(sys::Path(Filename), sys::MappedFile::READ_ACCESS, ErrMsg))
-    return true;
-  if (!File.map(ErrMsg)) {
-    File.close();
-    return true;
-  }
-  unsigned char *Buffer = reinterpret_cast<unsigned char*>(File.base());
-  if (!ParseBitcode(Buffer, File.size(), Filename))
-    return false;
-  assert(getErrorString() && "Didn't set an error string?");
-  if (ErrMsg) *ErrMsg = getErrorString();
-  return true;
-}
-
-
-
-//===----------------------------------------------------------------------===//
-// External interface
-//===----------------------------------------------------------------------===//
-
-/// getBitcodeModuleProvider - lazy function-at-a-time loading from a file.
-///
-ModuleProvider *llvm::getBitcodeModuleProvider(const std::string &Filename,
-                                               std::string *ErrMsg) {
-  if (Filename != std::string("-")) {
-    BitcodeFileReader *R = new BitcodeFileReader(Filename);
-    if (R->Read(ErrMsg)) {
-      delete R;
-      return 0;
-    }
-    return R;
-  }
-  
-  assert(0 && "FIXME: stdin reading unimp!");
-#if 0
-  // Read from stdin
-  BytecodeStdinReader *R = new BytecodeStdinReader();
-  if (R->Read(ErrMsg)) {
-    delete R;
-    return 0;
-  }
-  return R;
-#endif
-}
-
-/// ParseBitcodeFile - Read the specified bitcode file, returning the module.
-/// If an error occurs, return null and fill in *ErrMsg if non-null.
-Module *llvm::ParseBitcodeFile(const std::string &Filename,std::string *ErrMsg){
-  ModuleProvider *MP = getBitcodeModuleProvider(Filename, ErrMsg);
-  if (!MP) return 0;
-  Module *M = MP->releaseModule(ErrMsg);
-  delete MP;
-  return M;
-}