Cache common constants before lowering.

src/IceTargetLowering.cpp

 //===- subzero/src/IceTargetLowering.cpp - Basic lowering implementation --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Implements the skeleton of the TargetLowering class.
 ///
 /// Specifically this invokes the appropriate lowering method for a given
 /// instruction kind and driving global register allocation. It also implements
 /// the non-deleted instruction iteration in LoweringContext.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceTargetLowering.h"
+#include "IceTargetLowering.def"
 
 #include "IceBitVector.h"
 #include "IceCfg.h" // setError()
 #include "IceCfgNode.h"
 #include "IceGlobalContext.h"
 #include "IceGlobalInits.h"
 #include "IceInstVarIter.h"
 #include "IceOperand.h"
 #include "IceRegAlloc.h"
 
@@ skipping 222 matching lines @@
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X:                                                             \
     return ::X::createTargetLowering(Func);
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 void TargetLowering::staticInit(GlobalContext *Ctx) {
   const TargetArch Target = Ctx->getFlags().getTargetArch();
+  // Define zero constants used in translation.
+  {
+#define X(Ty)                                                                  \

[John, 2016/03/09 23:26:56]

This looks dangerous in the context of the browser translator - when Ctx is
deleted the array will point to bad data. I think this array should be a
non-static member in global context.

[Karl, 2016/03/16 22:50:52]

Done.

+  ConstZeroForType[IceType_##Ty] = Ctx->getConstantZero(IceType_##Ty);

[John, 2016/03/09 23:26:56]

It would be better if this used ICETYPE_TABLE... You could add a field to those
that is set to 1 if the type should have a constant zero

[Karl, 2016/03/16 22:50:52]

Since I moved the caching within method getConstantZero() within the global
context, this initialization is no longer necessary and has been removed.

+    CONSTANT_ZERO_BY_TYPE_TABLE
+#undef X
+  }
+  // Define runtime helper functions.

[Karl, 2016/03/16 22:50:52]

Moved initialization of helper function names to global context as well.

+  {
+#define X(Tag, Name)                                                           \
+  RuntimeHelperFunc[H_##Tag] = Ctx->getConstantExternSym(Name);
+    RUNTIME_HELPER_FUNCTIONS_TABLE
+#undef X
+  }
   // Call the specified target's static initializer.
   switch (Target) {
   default:
     badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X: {                                                           \
     static bool InitGuard##X = false;                                          \
     if (InitGuard##X) {                                                        \
       return;                                                                  \
     }                                                                          \
@@ skipping 10 matching lines @@
   assert(!Flags.getUseSandboxing() || !Flags.getUseNonsfi());
   if (Flags.getUseNonsfi()) {
     return TargetLowering::ST_Nonsfi;
   }
   if (Flags.getUseSandboxing()) {
     return TargetLowering::ST_NaCl;
   }
   return TargetLowering::ST_None;
 }
 
+Constant *TargetLowering::ConstZeroForType[IceType_NUM] = {

[Karl, 2016/03/16 22:50:52]

Removed these initializations and moved to the constructor of the global
context.

+#define X(tag, sizeLog2, align, elts, elty, str, rcstr) nullptr,
+    ICETYPE_TABLE
+#undef X
+};
+
+Constant *TargetLowering::RuntimeHelperFunc[H_Num] = {
+#define X(Tag, Name) nullptr,
+    RUNTIME_HELPER_FUNCTIONS_TABLE
+#undef X
+};
+
 TargetLowering::TargetLowering(Cfg *Func)
     : Func(Func), Ctx(Func->getContext()),
       SandboxingType(determineSandboxTypeFromFlags(Ctx->getFlags())) {}
 
 TargetLowering::AutoBundle::AutoBundle(TargetLowering *Target,
                                        InstBundleLock::Option Option)
     : Target(Target),
       NeedSandboxing(Target->Ctx->getFlags().getUseSandboxing()) {
   assert(!Target->AutoBundling);
   Target->AutoBundling = true;
@@ skipping 385 matching lines @@
     } else {
       NextStackOffset += Increment;
     }
     if (UsesFramePointer)
       Var->setStackOffset(-NextStackOffset);
     else
       Var->setStackOffset(SpillAreaSizeBytes - NextStackOffset);
   }
 }
 
-InstCall *TargetLowering::makeHelperCall(const IceString &Name, Variable *Dest,
-                                         SizeT MaxSrcs) {
+InstCall *TargetLowering::makeHelperCall(RuntimeHelperFuncKind Target,
+                                         Variable *Dest, SizeT MaxSrcs) {
   constexpr bool HasTailCall = false;
-  Constant *CallTarget = Ctx->getConstantExternSym(Name);
+  Operand *CallTarget = getRuntimeHelperFunc(Target);
   InstCall *Call =
       InstCall::create(Func, MaxSrcs, Dest, CallTarget, HasTailCall);
   return Call;
 }
 
 bool TargetLowering::shouldOptimizeMemIntrins() {
   return Ctx->getFlags().getOptLevel() >= Opt_1 ||
          Ctx->getFlags().getForceMemIntrinOpt();
 }
 
@@ skipping 168 matching lines @@
   case Target_##X:                                                             \
     return ::X::createTargetHeaderLowering(Ctx);
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice