[X86][Haswell][SchedModel] Add architecture specific scheduling models.

[oota-llvm.git] / lib / Bitcode / Reader / BitcodeReader.cpp

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 48fa9390412b13811d06f66594b88a6c0154d494..e5dfa723b04df5c610c4a74767ed15bbe7774774 100644 (file)
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -38,9 +38,14 @@ std::error_code BitcodeReader::materializeForwardReferencedFunctions() {
   // Prevent recursion.
   WillMaterializeAllForwardRefs = true;
 
-  while (!BasicBlockFwdRefs.empty()) {
-    Function *F = BasicBlockFwdRefs.begin()->first;
+  while (!BasicBlockFwdRefQueue.empty()) {
+    Function *F = BasicBlockFwdRefQueue.front();
+    BasicBlockFwdRefQueue.pop_front();
     assert(F && "Expected valid function");
+    if (!BasicBlockFwdRefs.count(F))
+      // Already materialized.
+      continue;
+
     // Check for a function that isn't materializable to prevent an infinite
     // loop.  When parsing a blockaddress stored in a global variable, there
     // isn't a trivial way to check if a function will have a body without a
@@ -52,6 +57,7 @@ std::error_code BitcodeReader::materializeForwardReferencedFunctions() {
     if (std::error_code EC = Materialize(F))
       return EC;
   }
+  assert(BasicBlockFwdRefs.empty() && "Function missing from queue");
 
   // Reset state.
   WillMaterializeAllForwardRefs = false;
@@ -72,6 +78,7 @@ void BitcodeReader::FreeState() {
   MDKindMap.clear();
 
   assert(BasicBlockFwdRefs.empty() && "Unresolved blockaddress fwd references");
+  BasicBlockFwdRefQueue.clear();
 }
 
 //===----------------------------------------------------------------------===//
@@ -1628,8 +1635,14 @@ std::error_code BitcodeReader::ParseConstants() {
       } else {
         // Otherwise insert a placeholder and remember it so it can be inserted
         // when the function is parsed.
-        BB = BasicBlock::Create(Context);
-        BasicBlockFwdRefs[Fn].emplace_back(BBID, BB);
+        auto &FwdBBs = BasicBlockFwdRefs[Fn];
+        if (FwdBBs.empty())
+          BasicBlockFwdRefQueue.push_back(Fn);
+        if (FwdBBs.size() < BBID + 1)
+          FwdBBs.resize(BBID + 1);
+        if (!FwdBBs[BBID])
+          FwdBBs[BBID] = BasicBlock::Create(Context);
+        BB = FwdBBs[BBID];
       }
       V = BlockAddress::get(Fn, BB);
       break;
@@ -1687,9 +1700,9 @@ std::error_code BitcodeReader::ParseUseLists() {
       unsigned NumUses = 0;
       SmallDenseMap<const Use *, unsigned, 16> Order;
       for (const Use &U : V->uses()) {
-        if (NumUses > Record.size())
+        if (++NumUses > Record.size())
           break;
-        Order[&U] = Record[NumUses++];
+        Order[&U] = Record[NumUses - 1];
       }
       if (Order.size() != Record.size() || NumUses > Record.size())
         // Mismatches can happen if the functions are being materialized lazily
@@ -2382,24 +2395,19 @@ std::error_code BitcodeReader::ParseFunctionBody(Function *F) {
           FunctionBBs[i] = BasicBlock::Create(Context, "", F);
       } else {
         auto &BBRefs = BBFRI->second;
-        std::sort(BBRefs.begin(), BBRefs.end(),
-                  [](const std::pair<unsigned, BasicBlock *> &LHS,
-                     const std::pair<unsigned, BasicBlock *> &RHS) {
-          return LHS.first < RHS.first;
-        });
-        unsigned R = 0, RE = BBRefs.size();
-        for (unsigned I = 0, E = FunctionBBs.size(); I != E; ++I)
-          if (R != RE && BBRefs[R].first == I) {
-            assert(I != 0 && "Invalid reference to entry block");
-            BasicBlock *BB = BBRefs[R++].second;
-            BB->insertInto(F);
-            FunctionBBs[I] = BB;
+        // Check for invalid basic block references.
+        if (BBRefs.size() > FunctionBBs.size())
+          return Error(BitcodeError::InvalidID);
+        assert(!BBRefs.empty() && "Unexpected empty array");
+        assert(!BBRefs.front() && "Invalid reference to entry block");
+        for (unsigned I = 0, E = FunctionBBs.size(), RE = BBRefs.size(); I != E;
+             ++I)
+          if (I < RE && BBRefs[I]) {
+            BBRefs[I]->insertInto(F);
+            FunctionBBs[I] = BBRefs[I];
           } else {
             FunctionBBs[I] = BasicBlock::Create(Context, "", F);
           }
-        // Check for invalid basic block references.
-        if (R != RE)
-          return Error(BitcodeError::InvalidID);
 
         // Erase from the table.
         BasicBlockFwdRefs.erase(BBFRI);
@@ -3503,10 +3511,17 @@ const std::error_category &llvm::BitcodeErrorCategory() {
 // External interface
 //===----------------------------------------------------------------------===//
 
-/// getLazyBitcodeModule - lazy function-at-a-time loading from a file.
+/// \brief Get a lazy one-at-time loading module from bitcode.
 ///
-ErrorOr<Module *> llvm::getLazyBitcodeModule(MemoryBuffer *Buffer,
-                                             LLVMContext &Context) {
+/// This isn't always used in a lazy context.  In particular, it's also used by
+/// \a parseBitcodeFile().  If this is truly lazy, then we need to eagerly pull
+/// in forward-referenced functions from block address references.
+///
+/// \param[in] WillMaterializeAll Set to \c true if the caller promises to
+/// materialize everything -- in particular, if this isn't truly lazy.
+static ErrorOr<Module *> getLazyBitcodeModuleImpl(MemoryBuffer *Buffer,
+                                                  LLVMContext &Context,
+                                                  bool WillMaterializeAll) {
   Module *M = new Module(Buffer->getBufferIdentifier(), Context);
   BitcodeReader *R = new BitcodeReader(Buffer, Context);
   M->setMaterializer(R);
@@ -3520,12 +3535,18 @@ ErrorOr<Module *> llvm::getLazyBitcodeModule(MemoryBuffer *Buffer,
   if (std::error_code EC = R->ParseBitcodeInto(M))
     return cleanupOnError(EC);
 
-  if (std::error_code EC = R->materializeForwardReferencedFunctions())
-    return cleanupOnError(EC);
+  if (!WillMaterializeAll)
+    // Resolve forward references from blockaddresses.
+    if (std::error_code EC = R->materializeForwardReferencedFunctions())
+      return cleanupOnError(EC);
 
   return M;
 }
 
+ErrorOr<Module *> llvm::getLazyBitcodeModule(MemoryBuffer *Buffer,
+                                             LLVMContext &Context) {
+  return getLazyBitcodeModuleImpl(Buffer, Context, false);
+}
 
 Module *llvm::getStreamedBitcodeModule(const std::string &name,
                                        DataStreamer *streamer,
@@ -3545,7 +3566,8 @@ Module *llvm::getStreamedBitcodeModule(const std::string &name,
 
 ErrorOr<Module *> llvm::parseBitcodeFile(MemoryBuffer *Buffer,
                                          LLVMContext &Context) {
-  ErrorOr<Module *> ModuleOrErr = getLazyBitcodeModule(Buffer, Context);
+  ErrorOr<Module *> ModuleOrErr =
+      getLazyBitcodeModuleImpl(Buffer, Context, true);
   if (!ModuleOrErr)
     return ModuleOrErr;
   Module *M = ModuleOrErr.get();