Cache common constants before lowering.

src/IceGlobalContext.h

 //===- subzero/src/IceGlobalContext.h - Global context defs -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Declares aspects of the compilation that persist across multiple
 /// functions.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICEGLOBALCONTEXT_H
 #define SUBZERO_SRC_ICEGLOBALCONTEXT_H
 
 #include "IceDefs.h"
 #include "IceClFlags.h"
 #include "IceIntrinsics.h"
 #include "IceRNG.h"
 #include "IceSwitchLowering.h"
+#include "IceTargetLowering.def"
 #include "IceThreading.h"
 #include "IceTimerTree.h"
 #include "IceTypes.h"
 #include "IceUtils.h"
 
 #include <array>
+#include <cassert>
 #include <functional>
 #include <memory>
 #include <mutex>
 #include <thread>
 #include <type_traits>
 #include <utility>
 #include <vector>
 
 namespace Ice {
 
 class ClFlags;
 class ConstantPool;
 class EmitterWorkItem;
 class FuncSigType;
 
+// Runtime helper function IDs
+
+enum class RuntimeHelper {
+#define X(Tag, Name) H_##Tag,
+  RUNTIME_HELPER_FUNCTIONS_TABLE
+#undef X
+      H_Num
+};
+
 /// LockedPtr is a way to provide automatically locked access to some object.
 template <typename T> class LockedPtr {
   LockedPtr() = delete;
   LockedPtr(const LockedPtr &) = delete;
   LockedPtr &operator=(const LockedPtr &) = delete;
 
 public:
   LockedPtr(T *Value, GlobalLockType *Lock) : Value(Value), Lock(Lock) {
     Lock->lock();
   }
@@ skipping 127 matching lines @@
 
   LockedPtr<ErrorCode> getErrorStatus() {
     return LockedPtr<ErrorCode>(&ErrorStatus, &ErrorStatusLock);
   }
 
   /// \name Manage Constants.
   /// @{
   // getConstant*() functions are not const because they might add something to
   // the constant pool.
   Constant *getConstantInt(Type Ty, int64_t Value);
-  Constant *getConstantInt1(int8_t ConstantInt1);
-  Constant *getConstantInt8(int8_t ConstantInt8);
-  Constant *getConstantInt16(int16_t ConstantInt16);
-  Constant *getConstantInt32(int32_t ConstantInt32);
-  Constant *getConstantInt64(int64_t ConstantInt64);
+  Constant *getConstantInt1(int8_t ConstantInt1) {
+    ConstantInt1 &= INT8_C(1);
+    switch (ConstantInt1) {
+    case 0:
+      return getConstantZero(IceType_i1);
+    case 1:
+      return ConstantTrue;
+    default:
+      assert(false && "getConstantInt1 not on true/false");
+      return getConstantInt1Internal(ConstantInt1);
+    }
+  }
+  Constant *getConstantInt8(int8_t ConstantInt8) {
+    switch (ConstantInt8) {
+    case 0:
+      return getConstantZero(IceType_i8);
+    default:
+      return getConstantInt8Internal(ConstantInt8);
+    }
+  }
+  Constant *getConstantInt16(int16_t ConstantInt16) {
+    switch (ConstantInt16) {
+    case 0:
+      return getConstantZero(IceType_i16);
+    default:
+      return getConstantInt16Internal(ConstantInt16);
+    }
+  }
+  Constant *getConstantInt32(int32_t ConstantInt32) {
+    switch (ConstantInt32) {
+    case 0:
+      return getConstantZero(IceType_i32);
+    default:
+      return getConstantInt32Internal(ConstantInt32);
+    }
+  }
+  Constant *getConstantInt64(int64_t ConstantInt64) {
+    switch (ConstantInt64) {
+    case 0:
+      return getConstantZero(IceType_i64);
+    default:
+      return getConstantInt64Internal(ConstantInt64);
+    }
+  }
   Constant *getConstantFloat(float Value);
   Constant *getConstantDouble(double Value);
   /// Returns a symbolic constant.
   Constant *getConstantSym(const RelocOffsetT Offset,
                            const RelocOffsetArray &OffsetExpr,
                            const IceString &Name, const IceString &EmitString);
   Constant *getConstantSym(RelocOffsetT Offset, const IceString &Name);
   Constant *getConstantExternSym(const IceString &Name);
   /// Returns an undef.
   Constant *getConstantUndef(Type Ty);
   /// Returns a zero value.
   Constant *getConstantZero(Type Ty);
   /// getConstantPool() returns a copy of the constant pool for constants of a
   /// given type.
   ConstantList getConstantPool(Type Ty);
   /// Returns a copy of the list of external symbols.
   ConstantList getConstantExternSyms();
   /// @}
+  Constant *getRuntimeHelperFunc(RuntimeHelper FuncID) const {
+    assert(FuncID < RuntimeHelper::H_Num);
+    Constant *Result = RuntimeHelperFunc[static_cast<size_t>(FuncID)];

[Jim Stichnoth, 2016/03/17 20:12:22]

Can you can use the enum value directly without the size_t cast?  Or is this
something different about enum classes?

(here and below)

[John, 2016/03/17 20:22:57]

yup, he needs the cast -- class enums are just like that, not implicitly
convertible to/from integer types.

+    assert(Result != nullptr && "No such runtime helper function");
+    return Result;
+  }
 
   /// Return a locked pointer to the registered jump tables.
   JumpTableDataList getJumpTables();
   /// Create a new jump table entry and return a reference to it.
   JumpTableData &addJumpTable(const IceString &FuncName, SizeT Id,
                               const JumpTableData::TargetList &TargetList);
 
   static const ClFlags &getFlags() { return Flags; }
 
   /// Allocate data of type T using the global allocator. We allow entities
@@ skipping 292 matching lines @@
   /// If !HasEmittedCode, SubZero will accumulate all Globals (which are "true"
   /// program global variables) until the first code WorkItem is seen.
   // TODO(jpp): move to EmitterContext.
   bool HasSeenCode = false;
   // TODO(jpp): move to EmitterContext.
   VariableDeclaration *ProfileBlockInfoVarDecl = nullptr;
   std::vector<VariableDeclaration *> ProfileBlockInfos;
   /// Indicates if global variable declarations can be disposed of right after
   /// lowering.
   bool DisposeGlobalVariablesAfterLowering = true;
+  Constant *ConstZeroForType[IceType_NUM];
+  Constant *ConstantTrue;
+  // Holds the constants representing each runtime helper function.
+  Constant *RuntimeHelperFunc[static_cast<size_t>(RuntimeHelper::H_Num)];
 
+  Constant *getConstantZeroInternal(Type Ty);
+  Constant *getConstantIntInternal(Type Ty, int64_t Value);
+  Constant *getConstantInt1Internal(int8_t ConstantInt1);
+  Constant *getConstantInt8Internal(int8_t ConstantInt8);
+  Constant *getConstantInt16Internal(int16_t ConstantInt16);
+  Constant *getConstantInt32Internal(int32_t ConstantInt32);
+  Constant *getConstantInt64Internal(int64_t ConstantInt64);
   LockedPtr<ArenaAllocator> getAllocator() {
     return LockedPtr<ArenaAllocator>(&Allocator, &AllocLock);
   }
   LockedPtr<VariableDeclarationList> getInitializerAllocator() {
     return LockedPtr<VariableDeclarationList>(&Globals, &InitAllocLock);
   }
   LockedPtr<ConstantPool> getConstPool() {
     return LockedPtr<ConstantPool>(ConstPool.get(), &ConstPoolLock);
   }
   LockedPtr<JumpTableDataList> getJumpTableList() {
@@ skipping 93 matching lines @@
   explicit OstreamLocker(GlobalContext *Ctx) : Ctx(Ctx) { Ctx->lockStr(); }
   ~OstreamLocker() { Ctx->unlockStr(); }
 
 private:
   GlobalContext *const Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALCONTEXT_H