Subzero. Performance tweaks.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 30 matching lines @@
 #include <cctype>    // isdigit(), isupper()
 #include <locale>    // locale
 
 namespace std {
 template <> struct hash<Ice::RelocatableTuple> {
   size_t operator()(const Ice::RelocatableTuple &Key) const {
     if (!Key.EmitString.empty()) {
       return hash<Ice::IceString>()(Key.EmitString);
     }
 
-    assert(!Key.OffsetExpr.empty());
-    if (Key.OffsetExpr[0]->hasOffset()) {
-      return hash<Ice::IceString>()(Key.Name) +
-             hash<Ice::RelocOffsetT>()(Key.OffsetExpr[0]->getOffset());
-    }
-
+    // If there's no emit string, then we use the relocatable's name, plus the
+    // hash of a combination of the number of OffsetExprs and the known, fixed
+    // offset for the reloc. We left shift the known relocatable by 5 trying to
+    // minimize the interation between the bits in OffsetExpr.size() and

[Jim Stichnoth, 2016/02/24 23:23:32]

interaction

[John, 2016/02/24 23:46:05]

Done.

+    // Key.Offset.
     return hash<Ice::IceString>()(Key.Name) +
-           hash<std::size_t>()(Key.OffsetExpr.size());
+           hash<std::size_t>()(Key.OffsetExpr.size() + (Key.Offset << 5));
   }
 };
 } // end of namespace std
 
 namespace Ice {
 
 namespace {
 
 // Define the key comparison function for the constant pool's unordered_map,
 // but only for key types of interest: integer types, floating point types, and
@@ skipping 217 matching lines @@
   ProfileBlockInfoVarDecl->setName("__Sz_block_profile_info");
   ProfileBlockInfoVarDecl->setSuppressMangling();
   ProfileBlockInfoVarDecl->setLinkage(llvm::GlobalValue::ExternalLinkage);
 
   TargetLowering::staticInit(this);
 }
 
 void GlobalContext::translateFunctions() {
   while (std::unique_ptr<Cfg> Func = optQueueBlockingPop()) {
     // Install Func in TLS for Cfg-specific container allocators.
-    Cfg::setCurrentCfg(Func.get());
+    CfgLocalAllocatorScope _(Func.get());
     // Reset per-function stats being accumulated in TLS.
     resetStats();
     // Set verbose level to none if the current function does NOT
     // match the -verbose-focus command-line option.
     if (!matchSymbolName(Func->getFunctionName(),
                          getFlags().getVerboseFocusOn()))
       Func->setVerbose(IceV_None);
     // Disable translation if -notranslate is specified, or if the
     // current function matches the -translate-only option.  If
     // translation is disabled, just dump the high-level IR and
     // continue.
     if (getFlags().getDisableTranslation() ||
         !matchSymbolName(Func->getFunctionName(),
                          getFlags().getTranslateOnly())) {
       Func->dump();
-      Cfg::setCurrentCfg(nullptr);
       continue; // Func goes out of scope and gets deleted
     }
 
     Func->translate();
     EmitterWorkItem *Item = nullptr;
     if (Func->hasError()) {
       getErrorStatus()->assign(EC_Translation);
       OstreamLocker L(this);
       getStrError() << "ICE translation error: " << Func->getFunctionName()
                     << ": " << Func->getError() << ": "
@@ skipping 18 matching lines @@
       case FT_Asm:
         // The Cfg has not been emitted yet, so stats are not ready
         // to be dumped.
         std::unique_ptr<VariableDeclarationList> GlobalInits =
             Func->getGlobalInits();
         Item = new EmitterWorkItem(Func->getSequenceNumber(), Func.release());
         Item->setGlobalInits(std::move(GlobalInits));
         break;
       }
     }
-    Cfg::setCurrentCfg(nullptr);
     assert(Item);
     emitQueueBlockingPush(Item);
     // The Cfg now gets deleted as Func goes out of scope.
   }
 }
 
 namespace {
 
 // Ensure Pending is large enough that Pending[Index] is valid.
 void resizePending(std::vector<EmitterWorkItem *> &Pending, uint32_t Index) {
@@ skipping 188 matching lines @@
         if (!BuildDefs::dump())
           llvm::report_fatal_error("WI_Cfg work item created inappropriately");
         lowerGlobalsIfNoCodeHasBeenSeen();
         accumulateGlobals(Item->getGlobalInits());
 
         assert(getFlags().getOutFileType() == FT_Asm);
         std::unique_ptr<Cfg> Func = Item->getCfg();
         // Unfortunately, we have to temporarily install the Cfg in TLS
         // because Variable::asType() uses the allocator to create the
         // differently-typed copy.
-        Cfg::setCurrentCfg(Func.get());
+        CfgLocalAllocatorScope _(Func.get());
         Func->emit();
-        Cfg::setCurrentCfg(nullptr);
         dumpStats(Func->getFunctionNameAndSize());
       } break;
       }
     }
     // Update the start index for next shuffling queue
     ShuffleStartIndex = ShuffleEndIndex;
   }
 
   // In case there are no code to be generated, we invoke the conditional
   // lowerGlobals again -- this is a no-op if code has been emitted.
@@ skipping 215 matching lines @@
 }
 
 Constant *GlobalContext::getConstantFloat(float ConstantFloat) {
   return getConstPool()->Floats.getOrAdd(this, ConstantFloat);
 }
 
 Constant *GlobalContext::getConstantDouble(double ConstantDouble) {
   return getConstPool()->Doubles.getOrAdd(this, ConstantDouble);
 }
 
-Constant *GlobalContext::getConstantSym(const RelocOffsetArray &Offset,
+Constant *GlobalContext::getConstantSym(const RelocOffsetT Offset,
+                                        const RelocOffsetArray &OffsetExpr,
                                         const IceString &Name,
                                         const IceString &EmitString,
                                         bool SuppressMangling) {
   return getConstPool()->Relocatables.getOrAdd(
-      this, RelocatableTuple(Offset, Name, EmitString, SuppressMangling));
+      this,
+      RelocatableTuple(Offset, OffsetExpr, Name, EmitString, SuppressMangling));
 }
 
 Constant *GlobalContext::getConstantSym(RelocOffsetT Offset,
                                         const IceString &Name,
                                         bool SuppressMangling) {
   constexpr char EmptyEmitString[] = "";
-  return getConstantSym({RelocOffset::create(this, Offset)}, Name,
-                        EmptyEmitString, SuppressMangling);
+  return getConstantSym(Offset, {}, Name, EmptyEmitString, SuppressMangling);
 }
 
 Constant *GlobalContext::getConstantExternSym(const IceString &Name) {
   constexpr RelocOffsetT Offset = 0;
   constexpr bool SuppressMangling = true;
   return getConstPool()->ExternRelocatables.getOrAdd(
-      this, RelocatableTuple({RelocOffset::create(this, Offset)}, Name,
-                             SuppressMangling));
+      this, RelocatableTuple(Offset, {}, Name, SuppressMangling));
 }
 
 Constant *GlobalContext::getConstantUndef(Type Ty) {
   return getConstPool()->Undefs.getOrAdd(this, Ty);
 }
 
 // All locking is done by the getConstant*() target function.
 Constant *GlobalContext::getConstantZero(Type Ty) {
   switch (Ty) {
   case IceType_i1:
@@ skipping 206 matching lines @@
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice