PNaCl localmod mods in LLVM to 223109 (local files only)

lib/Bitcode/NaCl/Reader/NaClBitcodeReader.cpp

 //===- NaClBitcodeReader.cpp ----------------------------------------------===//
 //     Internal NaClBitcodeReader implementation
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
@@ skipping 1008 matching lines @@
       bool isProto = Record[2];
       GlobalValue::LinkageTypes Linkage;
       if (!naclbitc::DecodeLinkage(Record[3], Linkage))
         return Error(InvalidValue, "Unknown linkage type");
       Func->setLinkage(Linkage);
       ValueList.push_back(Func);
 
       // If this is a function with a body, remember the prototype we are
       // creating now, so that we can match up the body with them later.
       if (!isProto) {
+        Func->setIsMaterializable(true);
         FunctionsWithBodies.push_back(Func);
         if (LazyStreamer) DeferredFunctionInfo[Func] = 0;
       }
       break;
     }
     }
     Record.clear();
   }
   return std::error_code();
 }
@@ skipping 685 matching lines @@
   }
   return std::error_code();
 }
 
 //===----------------------------------------------------------------------===//
 // GVMaterializer implementation
 //===----------------------------------------------------------------------===//
 
 void NaClBitcodeReader::releaseBuffer() { Buffer.release(); }
 
-bool NaClBitcodeReader::isMaterializable(const GlobalValue *GV) const {
-  if (const Function *F = dyn_cast<Function>(GV)) {
-    return F->isDeclaration() &&
-      DeferredFunctionInfo.count(const_cast<Function*>(F));
-  }
-  return false;
-}
-
-std::error_code NaClBitcodeReader::Materialize(GlobalValue *GV) {
+std::error_code NaClBitcodeReader::materialize(GlobalValue *GV) {
   Function *F = dyn_cast<Function>(GV);
   // If it's not a function or is already material, ignore the request.
   if (!F || !F->isMaterializable())
     return std::error_code();
 
   DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F);
   assert(DFII != DeferredFunctionInfo.end() && "Deferred function not found!");
   // If its position is recorded as 0, its body is somewhere in the stream
   // but we haven't seen it yet.
   if (DFII->second == 0) {
     if (std::error_code EC = FindFunctionInStream(F, DFII)) {
       return EC;
     }
   }
 
   // Move the bit stream to the saved position of the deferred function body.
   Stream.JumpToBit(DFII->second);
 
   if (std::error_code EC = ParseFunctionBody(F))
     return EC;
+  F->setIsMaterializable(false);
 
   // Upgrade any old intrinsic calls in the function.
   for (UpgradedIntrinsicMap::iterator I = UpgradedIntrinsics.begin(),
        E = UpgradedIntrinsics.end(); I != E; ++I) {
     if (I->first != I->second) {
       for (Value::use_iterator UI = I->first->use_begin(),
            UE = I->first->use_end(); UI != UE; ) {
         if (CallInst* CI = dyn_cast<CallInst>(*UI++))
           UpgradeIntrinsicCall(CI, I->second);
       }
@@ skipping 13 matching lines @@
 void NaClBitcodeReader::Dematerialize(GlobalValue *GV) {
   Function *F = dyn_cast<Function>(GV);
   // If this function isn't dematerializable, this is a noop.
   if (!F || !isDematerializable(F))
     return;
 
   assert(DeferredFunctionInfo.count(F) && "No info to read function later?");
 
   // Just forget the function body, we can remat it later.
   F->dropAllReferences();
+  F->setIsMaterializable(true);
 }
 
 
 std::error_code NaClBitcodeReader::MaterializeModule(Module *M) {
   assert(M == TheModule &&
          "Can only Materialize the Module this NaClBitcodeReader is attached to.");
   // Iterate over the module, deserializing any functions that are still on
   // disk.
   for (Module::iterator F = TheModule->begin(), E = TheModule->end();
        F != E; ++F) {
     if (F->isMaterializable()) {
-      if (std::error_code EC = Materialize(F))
+      if (std::error_code EC = materialize(F))
         return EC;
     }
   }
 
   // At this point, if there are any function bodies, the current bit is
   // pointing to the END_BLOCK record after them. Now make sure the rest
   // of the bits in the module have been read.
   if (NextUnreadBit)
     ParseModule(true);
 
@@ skipping 53 matching lines @@
   Stream.init(StreamFile.get());
   if (AcceptHeader())
     return Error(InvalidBitstream, Header.Unsupported());
   return std::error_code();
 }
 
 //===----------------------------------------------------------------------===//
 // External interface
 //===----------------------------------------------------------------------===//
 
-/// getNaClLazyBitcodeModule - lazy function-at-a-time loading from a file.
+/// \brief Get a lazy one-at-time loading module from bitcode.
 ///
+/// This isn't always used in a lazy context.  In particular, it's also used by
+/// \a NaClParseBitcodeFile(). Compared to the upstream LLVM bitcode reader,
+/// NaCl does not support BlockAddresses, so it does not need to materialize
+/// forward-referenced functions from block address references.
 ErrorOr<Module *> llvm::getNaClLazyBitcodeModule(
-    MemoryBuffer *Buffer, LLVMContext& Context, raw_ostream *Verbose,
-    bool AcceptSupportedOnly) {
+    std::unique_ptr<MemoryBuffer> &&Buffer, LLVMContext& Context,
+    raw_ostream *Verbose, bool AcceptSupportedOnly) {
   Module *M = new Module(Buffer->getBufferIdentifier(), Context);
   NaClBitcodeReader *R =
-      new NaClBitcodeReader(Buffer, Context, Verbose, AcceptSupportedOnly);
+      new NaClBitcodeReader(Buffer.get(), Context, Verbose, AcceptSupportedOnly);
   M->setMaterializer(R);
-  if (std::error_code EC = R->ParseBitcodeInto(M)) {
+
+  auto cleanupOnError = [&](std::error_code EC) {
     R->releaseBuffer(); // Never take ownership on error.
     delete M;  // Also deletes R.
     return EC;
-  }
+  };
 
+  if (std::error_code EC = R->ParseBitcodeInto(M))
+    return cleanupOnError(EC);
+
+  Buffer.release(); // The BitcodeReader owns it now.
   return M;
 }
 
 
 Module *llvm::getNaClStreamedBitcodeModule(const std::string &name,
                                            StreamingMemoryObject *Streamer,
                                            LLVMContext &Context,
                                            raw_ostream *Verbose,
                                            std::string *ErrMsg,
                                            bool AcceptSupportedOnly) {
   Module *M = new Module(name, Context);
   NaClBitcodeReader *R =
       new NaClBitcodeReader(Streamer, Context, Verbose,
                             AcceptSupportedOnly);
   M->setMaterializer(R);
   if (std::error_code EC = R->ParseBitcodeInto(M)) {
     if (ErrMsg)
       *ErrMsg = EC.message();
     delete M;  // Also deletes R.
     return nullptr;
   }
 
   return M;
 }
 
-/// NaClParseBitcodeFile - Read the specified bitcode file, returning the module.
-/// If an error occurs, return null and fill in *ErrMsg if non-null.
 ErrorOr<Module *> llvm::NaClParseBitcodeFile(
-    MemoryBuffer *Buffer, LLVMContext& Context, raw_ostream *Verbose,
+    MemoryBufferRef Buffer, LLVMContext& Context, raw_ostream *Verbose,
     bool AcceptSupportedOnly){
+  std::unique_ptr<MemoryBuffer> Buf = MemoryBuffer::getMemBuffer(Buffer, false);
   ErrorOr<Module *> ModuleOrErr =
-      getNaClLazyBitcodeModule(Buffer, Context, Verbose, AcceptSupportedOnly);
+      getNaClLazyBitcodeModule(std::move(Buf), Context, Verbose, AcceptSupportedOnly);
   if (!ModuleOrErr)
     return ModuleOrErr;
   Module *M = ModuleOrErr.get();
   // Read in the entire module, and destroy the NaClBitcodeReader.
-  if (std::error_code EC = M->materializeAllPermanently(true)) {
-    // Be sure the input buffer is released on error
-    // (materalializeAllPermanently doesn't release the buffer on error).
-    // TODO(kschimpf) Revisit this when we merge to tip of LLVM.
-    if (GVMaterializer *Materializer = M->getMaterializer())
-      Materializer->releaseBuffer();
+  if (std::error_code EC = M->materializeAllPermanently()) {
     delete M;
     return EC;
   }
 
   // TODO: Restore the use-lists to the in-memory state when the bitcode was
   // written.  We must defer until the Module has been fully materialized.
 
   return M;
 }