Cache common constants before lowering.

src/IceTargetLowering.h

 //===- subzero/src/IceTargetLowering.h - Lowering interface -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 10 matching lines @@
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ICETARGETLOWERING_H
 #define SUBZERO_SRC_ICETARGETLOWERING_H
 
 #include "IceDefs.h"
 #include "IceBitVector.h"
 #include "IceCfgNode.h"
 #include "IceInst.h" // for the names of the Inst subtypes
 #include "IceOperand.h"
+#include "IceTargetLowering.def"
 #include "IceTypes.h"
 
 #include <utility>
 
 namespace Ice {
 
 // UnimplementedError is defined as a macro so that we can get actual line
 // numbers.
 #define UnimplementedError(Flags)                                              \
   do {                                                                         \
@@ skipping 413 matching lines @@
   void assignVarStackSlots(VarList &SortedSpilledVariables,
                            size_t SpillAreaPaddingBytes,
                            size_t SpillAreaSizeBytes,
                            size_t GlobalsAndSubsequentPaddingSize,
                            bool UsesFramePointer);
 
   /// Sort the variables in Source based on required alignment. The variables
   /// with the largest alignment need are placed in the front of the Dest list.
   void sortVarsByAlignment(VarList &Dest, const VarList &Source) const;
 
-  /// Make a call to an external helper function.
-  InstCall *makeHelperCall(const IceString &Name, Variable *Dest,
+  // Runtime helper function names

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

Also moved this enum to global context, so that we can move
getRuntimeHelperFunc() to global context.

+  enum RuntimeHelperFuncKind {
+#define X(Tag, Name) H_##Tag,
+    RUNTIME_HELPER_FUNCTIONS_TABLE
+#undef X
+        H_Num
+  };
+
+  InstCall *makeHelperCall(RuntimeHelperFuncKind Target, Variable *Dest,
                            SizeT MaxSrcs);
 
   void _set_dest_redefined() { Context.getLastInserted()->setDestRedefined(); }
 
   bool shouldOptimizeMemIntrins();
 
   void scalarizeArithmetic(InstArithmetic::OpKind K, Variable *Dest,
                            Operand *Src0, Operand *Src1);
 
   /// Generalizes scalarizeArithmetic to support other instruction types.
@@ skipping 86 matching lines @@
 
   Cfg *Func;
   GlobalContext *Ctx;
   bool HasComputedFrame = false;
   bool CallsReturnsTwice = false;
   SizeT NextLabelNumber = 0;
   SizeT NextJumpTableNumber = 0;
   LoweringContext Context;
   const SandboxType SandboxingType = ST_None;
 
-  // Runtime helper function names
-  const static constexpr char *H_bitcast_16xi1_i16 = "__Sz_bitcast_16xi1_i16";
-  const static constexpr char *H_bitcast_8xi1_i8 = "__Sz_bitcast_8xi1_i8";
-  const static constexpr char *H_bitcast_i16_16xi1 = "__Sz_bitcast_i16_16xi1";
-  const static constexpr char *H_bitcast_i8_8xi1 = "__Sz_bitcast_i8_8xi1";
-  const static constexpr char *H_call_ctpop_i32 = "__popcountsi2";
-  const static constexpr char *H_call_ctpop_i64 = "__popcountdi2";
-  const static constexpr char *H_call_longjmp = "longjmp";
-  const static constexpr char *H_call_memcpy = "memcpy";
-  const static constexpr char *H_call_memmove = "memmove";
-  const static constexpr char *H_call_memset = "memset";
-  const static constexpr char *H_call_read_tp = "__nacl_read_tp";
-  const static constexpr char *H_call_setjmp = "setjmp";
-  const static constexpr char *H_fptosi_f32_i64 = "__Sz_fptosi_f32_i64";
-  const static constexpr char *H_fptosi_f64_i64 = "__Sz_fptosi_f64_i64";
-  const static constexpr char *H_fptoui_4xi32_f32 = "__Sz_fptoui_4xi32_f32";
-  const static constexpr char *H_fptoui_f32_i32 = "__Sz_fptoui_f32_i32";
-  const static constexpr char *H_fptoui_f32_i64 = "__Sz_fptoui_f32_i64";
-  const static constexpr char *H_fptoui_f64_i32 = "__Sz_fptoui_f64_i32";
-  const static constexpr char *H_fptoui_f64_i64 = "__Sz_fptoui_f64_i64";
-  const static constexpr char *H_frem_f32 = "fmodf";
-  const static constexpr char *H_frem_f64 = "fmod";
+  /// Returns constant zero of Ty.

[Jim Stichnoth, 2016/03/10 00:24:46]

You should probably also try to capture the calls to
Ctx->getConstantInt{1,8,16,32,64}(0).  That would capture all the integer zeroes
that appear directly in the pexe.

Optionally, capture the lookups of 0.0, but that is slightly tricky because you
want to match +0.0 and not -0.0.

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

The plan was to capture more constants. This CL was to set up the framework for
extending to other constants. Did add additional code to capture cached values
for the different called paths for constants.

Also added "i1 true" to the list of cached constants.

+  Constant *getConstantZero(Type Ty) const {
+    assert(Ty < IceType_NUM);
+    if (Constant *Result = ConstZeroForType[Ty])
+      return Result;
+    return Ctx->getConstantZero(Ty);
+  }
+
+  /// Returns the constant defining the corresponding runtime helper function.
+  Constant *getRuntimeHelperFunc(RuntimeHelperFuncKind Kind) const {

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

Moved this to global context, and modified body (here) to simply call the
version in the global context.

+    assert(Kind < H_Num);
+    Constant *Result = RuntimeHelperFunc[Kind];
+    assert(Result != nullptr && "No such runtime helper function");
+    return Result;
+  }
+
   const static constexpr char *H_getIP_prefix = "__Sz_getIP_";
-  const static constexpr char *H_sdiv_i32 = "__divsi3";
-  const static constexpr char *H_sdiv_i64 = "__divdi3";
-  const static constexpr char *H_sitofp_i64_f32 = "__Sz_sitofp_i64_f32";
-  const static constexpr char *H_sitofp_i64_f64 = "__Sz_sitofp_i64_f64";
-  const static constexpr char *H_srem_i32 = "__modsi3";
-  const static constexpr char *H_srem_i64 = "__moddi3";
-  const static constexpr char *H_udiv_i32 = "__udivsi3";
-  const static constexpr char *H_udiv_i64 = "__udivdi3";
-  const static constexpr char *H_uitofp_4xi32_4xf32 = "__Sz_uitofp_4xi32_4xf32";
-  const static constexpr char *H_uitofp_i32_f32 = "__Sz_uitofp_i32_f32";
-  const static constexpr char *H_uitofp_i32_f64 = "__Sz_uitofp_i32_f64";
-  const static constexpr char *H_uitofp_i64_f32 = "__Sz_uitofp_i64_f32";
-  const static constexpr char *H_uitofp_i64_f64 = "__Sz_uitofp_i64_f64";
-  const static constexpr char *H_urem_i32 = "__umodsi3";
-  const static constexpr char *H_urem_i64 = "__umoddi3";
+
+private:
+  // Holds constant zero for each type.
+  static Constant *ConstZeroForType[IceType_NUM];

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

What do you think of making this array a non-static member of global context?
Constants are tied to global context anyways.

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

Moved to global context, and used as cache inside method getConstantZero().

+  // Holds the constants representing each runtime helper function.
+  static Constant *RuntimeHelperFunc[H_Num];

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

Also moved this array to global context (as non-static).

 };
 
 /// TargetDataLowering is used for "lowering" data including initializers for
 /// global variables, and the internal constant pools. It is separated out from
 /// TargetLowering because it does not require a Cfg.
 class TargetDataLowering {
   TargetDataLowering() = delete;
   TargetDataLowering(const TargetDataLowering &) = delete;
   TargetDataLowering &operator=(const TargetDataLowering &) = delete;
 
@@ skipping 35 matching lines @@
   virtual void lower() {}
 
 protected:
   explicit TargetHeaderLowering(GlobalContext *Ctx) : Ctx(Ctx) {}
   GlobalContext *Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERING_H