Cache common constants before lowering.

src/IceTargetLoweringX86BaseImpl.h

 //===- subzero/src/IceTargetLoweringX86BaseImpl.h - x86 lowering -*- C++ -*-==//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 4043 matching lines @@
         // in x86-64, __popcountsi2 is not defined, so we cheat a bit by
         // converting it to a 64-bit value, and using ctpop_i64. _movzx should
         // ensure we will not have any bits set on Val's upper 32 bits.
         Variable *V = makeReg(IceType_i64);
         _movzx(V, Val);
         Val = V;
       }
       ValTy = IceType_i64;
     }
 
-    InstCall *Call = makeHelperCall(
-        ValTy == IceType_i32 ? H_call_ctpop_i32 : H_call_ctpop_i64, T, 1);
+    InstCall *Call =
+        makeHelperCall(ValTy == IceType_i32 ? RuntimeHelper::H_call_ctpop_i32
+                                            : RuntimeHelper::H_call_ctpop_i64,
+                       T, 1);
     Call->addArg(Val);
     lowerCall(Call);
     // The popcount helpers always return 32-bit values, while the intrinsic's
     // signature matches the native POPCNT instruction and fills a 64-bit reg
     // (in 64-bit mode). Thus, clear the upper bits of the dest just in case
     // the user doesn't do that in the IR. If the user does that in the IR,
     // then this zero'ing instruction is dead and gets optimized out.
     if (!Traits::Is64Bit) {
       assert(T == Dest);
       if (Val->getType() == IceType_i64) {
@@ skipping 72 matching lines @@
       Src = legalizeToReg(Src);
     }
     _pand(T, Src);
     if (isVectorType(Ty))
       _movp(Dest, T);
     else
       _mov(Dest, T);
     return;
   }
   case Intrinsics::Longjmp: {
-    InstCall *Call = makeHelperCall(H_call_longjmp, nullptr, 2);
+    InstCall *Call = makeHelperCall(RuntimeHelper::H_call_longjmp, nullptr, 2);
     Call->addArg(Instr->getArg(0));
     Call->addArg(Instr->getArg(1));
     lowerCall(Call);
     return;
   }
   case Intrinsics::Memcpy: {
     lowerMemcpy(Instr->getArg(0), Instr->getArg(1), Instr->getArg(2));
     return;
   }
   case Intrinsics::Memmove: {
     lowerMemmove(Instr->getArg(0), Instr->getArg(1), Instr->getArg(2));
     return;
   }
   case Intrinsics::Memset: {
     lowerMemset(Instr->getArg(0), Instr->getArg(1), Instr->getArg(2));
     return;
   }
   case Intrinsics::NaClReadTP: {
     if (NeedSandboxing) {
       Operand *Src =
           dispatchToConcrete(&ConcreteTarget::createNaClReadTPSrcOperand);
       Variable *Dest = Instr->getDest();
       Variable *T = nullptr;
       _mov(T, Src);
       _mov(Dest, T);
     } else {
-      InstCall *Call = makeHelperCall(H_call_read_tp, Instr->getDest(), 0);
+      InstCall *Call =
+          makeHelperCall(RuntimeHelper::H_call_read_tp, Instr->getDest(), 0);
       lowerCall(Call);
     }
     return;
   }
   case Intrinsics::Setjmp: {
-    InstCall *Call = makeHelperCall(H_call_setjmp, Instr->getDest(), 1);
+    InstCall *Call =
+        makeHelperCall(RuntimeHelper::H_call_setjmp, Instr->getDest(), 1);
     Call->addArg(Instr->getArg(0));
     lowerCall(Call);
     return;
   }
   case Intrinsics::Sqrt: {
     Operand *Src = legalize(Instr->getArg(0));
     Variable *Dest = Instr->getDest();
     Variable *T = makeReg(Dest->getType());
     _sqrtss(T, Src);
     _mov(Dest, T);
@@ skipping 553 matching lines @@
 
     // Lower the remaining bytes. Adjust to larger types in order to make use
     // of overlaps in the copies.
     Type LeftOverTy = firstTypeThatFitsSize(RemainingBytes);
     Offset = CountValue - typeWidthInBytes(LeftOverTy);
     copyMemory(LeftOverTy, DestBase, SrcBase, Offset);
     return;
   }
 
   // Fall back on a function call
-  InstCall *Call = makeHelperCall(H_call_memcpy, nullptr, 3);
+  InstCall *Call = makeHelperCall(RuntimeHelper::H_call_memcpy, nullptr, 3);
   Call->addArg(Dest);
   Call->addArg(Src);
   Call->addArg(Count);
   lowerCall(Call);
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::lowerMemmove(Operand *Dest, Operand *Src,
                                              Operand *Count) {
   // There is a load and store for each chunk in the unroll
@@ skipping 51 matching lines @@
     // Copy the data out into the destination memory
     for (size_t i = 0; i < N; ++i) {
       std::tie(Ty, Offset, Reg) = Moves[i];
       typedStore(Ty, Reg, DestBase, Offset);
     }
 
     return;
   }
 
   // Fall back on a function call
-  InstCall *Call = makeHelperCall(H_call_memmove, nullptr, 3);
+  InstCall *Call = makeHelperCall(RuntimeHelper::H_call_memmove, nullptr, 3);
   Call->addArg(Dest);
   Call->addArg(Src);
   Call->addArg(Count);
   lowerCall(Call);
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::lowerMemset(Operand *Dest, Operand *Val,
                                             Operand *Count) {
   constexpr uint32_t BytesPerStorep = 16;
@@ skipping 88 matching lines @@
   // extended to a stack slot size because the PNaCl ABI requires arguments to
   // be at least 32 bits wide.
   Operand *ValExt;
   if (IsValConst) {
     ValExt = Ctx->getConstantInt(stackSlotType(), ValValue);
   } else {
     Variable *ValExtVar = Func->makeVariable(stackSlotType());
     lowerCast(InstCast::create(Func, InstCast::Zext, ValExtVar, Val));
     ValExt = ValExtVar;
   }
-  InstCall *Call = makeHelperCall(H_call_memset, nullptr, 3);
+  InstCall *Call = makeHelperCall(RuntimeHelper::H_call_memset, nullptr, 3);
   Call->addArg(Dest);
   Call->addArg(ValExt);
   Call->addArg(Count);
   lowerCall(Call);
 }
 
 class AddressOptimizer {
   AddressOptimizer() = delete;
   AddressOptimizer(const AddressOptimizer &) = delete;
   AddressOptimizer &operator=(const AddressOptimizer &) = delete;
@@ skipping 1245 matching lines @@
   // during phi lowering assignments
   BoolFlagSaver B(RandomizationPoolingPaused, true);
   PhiLowering::prelowerPhis32Bit<TargetX86Base<TraitsType>>(
       this, Context.getNode(), Func);
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::genTargetHelperCallFor(Inst *Instr) {
   uint32_t StackArgumentsSize = 0;
   if (auto *Arith = llvm::dyn_cast<InstArithmetic>(Instr)) {
-    const char *HelperName = nullptr;
+    RuntimeHelper HelperID = RuntimeHelper::H_Num;
     Variable *Dest = Arith->getDest();
     Type DestTy = Dest->getType();
     if (!Traits::Is64Bit && DestTy == IceType_i64) {
       switch (Arith->getOp()) {
       default:
         return;
       case InstArithmetic::Udiv:
-        HelperName = H_udiv_i64;
+        HelperID = RuntimeHelper::H_udiv_i64;
         break;
       case InstArithmetic::Sdiv:
-        HelperName = H_sdiv_i64;
+        HelperID = RuntimeHelper::H_sdiv_i64;
         break;
       case InstArithmetic::Urem:
-        HelperName = H_urem_i64;
+        HelperID = RuntimeHelper::H_urem_i64;
         break;
       case InstArithmetic::Srem:
-        HelperName = H_srem_i64;
+        HelperID = RuntimeHelper::H_srem_i64;
         break;
       }
     } else if (isVectorType(DestTy)) {
       Variable *Dest = Arith->getDest();
       Operand *Src0 = Arith->getSrc(0);
       Operand *Src1 = Arith->getSrc(1);
       switch (Arith->getOp()) {
       default:
         return;
       case InstArithmetic::Mul:
@@ skipping 13 matching lines @@
         scalarizeArithmetic(Arith->getOp(), Dest, Src0, Src1);
         Arith->setDeleted();
         return;
       }
     } else {
       switch (Arith->getOp()) {
       default:
         return;
       case InstArithmetic::Frem:
         if (isFloat32Asserting32Or64(DestTy))
-          HelperName = H_frem_f32;
+          HelperID = RuntimeHelper::H_frem_f32;
         else
-          HelperName = H_frem_f64;
+          HelperID = RuntimeHelper::H_frem_f64;
       }
     }
     constexpr SizeT MaxSrcs = 2;
-    InstCall *Call = makeHelperCall(HelperName, Dest, MaxSrcs);
+    InstCall *Call = makeHelperCall(HelperID, Dest, MaxSrcs);
     Call->addArg(Arith->getSrc(0));
     Call->addArg(Arith->getSrc(1));
     StackArgumentsSize = getCallStackArgumentsSizeBytes(Call);
     Context.insert(Call);
     Arith->setDeleted();
   } else if (auto *Cast = llvm::dyn_cast<InstCast>(Instr)) {
     InstCast::OpKind CastKind = Cast->getCastKind();
     Operand *Src0 = Cast->getSrc(0);
     const Type SrcType = Src0->getType();
     Variable *Dest = Cast->getDest();
     const Type DestTy = Dest->getType();
-    const char *HelperName = nullptr;
+    RuntimeHelper HelperID = RuntimeHelper::H_Num;
     Variable *CallDest = Dest;
     switch (CastKind) {
     default:
       return;
     case InstCast::Fptosi:
       if (!Traits::Is64Bit && DestTy == IceType_i64) {
-        HelperName = isFloat32Asserting32Or64(SrcType) ? H_fptosi_f32_i64
-                                                       : H_fptosi_f64_i64;
+        HelperID = isFloat32Asserting32Or64(SrcType)
+                       ? RuntimeHelper::H_fptosi_f32_i64
+                       : RuntimeHelper::H_fptosi_f64_i64;
       } else {
         return;
       }
       break;
     case InstCast::Fptoui:
       if (isVectorType(DestTy)) {
         assert(DestTy == IceType_v4i32 && SrcType == IceType_v4f32);
-        HelperName = H_fptoui_4xi32_f32;
+        HelperID = RuntimeHelper::H_fptoui_4xi32_f32;
       } else if (DestTy == IceType_i64 ||
                  (!Traits::Is64Bit && DestTy == IceType_i32)) {
         if (Traits::Is64Bit) {
-          HelperName = isFloat32Asserting32Or64(SrcType) ? H_fptoui_f32_i64
-                                                         : H_fptoui_f64_i64;
+          HelperID = isFloat32Asserting32Or64(SrcType)
+                         ? RuntimeHelper::H_fptoui_f32_i64
+                         : RuntimeHelper::H_fptoui_f64_i64;
         } else if (isInt32Asserting32Or64(DestTy)) {
-          HelperName = isFloat32Asserting32Or64(SrcType) ? H_fptoui_f32_i32
-                                                         : H_fptoui_f64_i32;
+          HelperID = isFloat32Asserting32Or64(SrcType)
+                         ? RuntimeHelper::H_fptoui_f32_i32
+                         : RuntimeHelper::H_fptoui_f64_i32;
         } else {
-          HelperName = isFloat32Asserting32Or64(SrcType) ? H_fptoui_f32_i64
-                                                         : H_fptoui_f64_i64;
+          HelperID = isFloat32Asserting32Or64(SrcType)
+                         ? RuntimeHelper::H_fptoui_f32_i64
+                         : RuntimeHelper::H_fptoui_f64_i64;
         }
       } else {
         return;
       }
       break;
     case InstCast::Sitofp:
       if (!Traits::Is64Bit && SrcType == IceType_i64) {
-        HelperName = isFloat32Asserting32Or64(DestTy) ? H_sitofp_i64_f32
-                                                      : H_sitofp_i64_f64;
+        HelperID = isFloat32Asserting32Or64(DestTy)
+                       ? RuntimeHelper::H_sitofp_i64_f32
+                       : RuntimeHelper::H_sitofp_i64_f64;
       } else {
         return;
       }
       break;
     case InstCast::Uitofp:
       if (isVectorType(SrcType)) {
         assert(DestTy == IceType_v4f32 && SrcType == IceType_v4i32);
-        HelperName = H_uitofp_4xi32_4xf32;
+        HelperID = RuntimeHelper::H_uitofp_4xi32_4xf32;
       } else if (SrcType == IceType_i64 ||
                  (!Traits::Is64Bit && SrcType == IceType_i32)) {
         if (isInt32Asserting32Or64(SrcType)) {
-          HelperName = isFloat32Asserting32Or64(DestTy) ? H_uitofp_i32_f32
-                                                        : H_uitofp_i32_f64;
+          HelperID = isFloat32Asserting32Or64(DestTy)
+                         ? RuntimeHelper::H_uitofp_i32_f32
+                         : RuntimeHelper::H_uitofp_i32_f64;
         } else {
-          HelperName = isFloat32Asserting32Or64(DestTy) ? H_uitofp_i64_f32
-                                                        : H_uitofp_i64_f64;
+          HelperID = isFloat32Asserting32Or64(DestTy)
+                         ? RuntimeHelper::H_uitofp_i64_f32
+                         : RuntimeHelper::H_uitofp_i64_f64;
         }
       } else {
         return;
       }
       break;
     case InstCast::Bitcast: {
       if (DestTy == Src0->getType())
         return;
       switch (DestTy) {
       default:
         return;
       case IceType_i8:
         assert(Src0->getType() == IceType_v8i1);
-        HelperName = H_bitcast_8xi1_i8;
+        HelperID = RuntimeHelper::H_bitcast_8xi1_i8;
         CallDest = Func->makeVariable(IceType_i32);
         break;
       case IceType_i16:
         assert(Src0->getType() == IceType_v16i1);
-        HelperName = H_bitcast_16xi1_i16;
+        HelperID = RuntimeHelper::H_bitcast_16xi1_i16;
         CallDest = Func->makeVariable(IceType_i32);
         break;
       case IceType_v8i1: {
         assert(Src0->getType() == IceType_i8);
-        HelperName = H_bitcast_i8_8xi1;
+        HelperID = RuntimeHelper::H_bitcast_i8_8xi1;
         Variable *Src0AsI32 = Func->makeVariable(stackSlotType());
         // Arguments to functions are required to be at least 32 bits wide.
         Context.insert<InstCast>(InstCast::Zext, Src0AsI32, Src0);
         Src0 = Src0AsI32;
       } break;
       case IceType_v16i1: {
         assert(Src0->getType() == IceType_i16);
-        HelperName = H_bitcast_i16_16xi1;
+        HelperID = RuntimeHelper::H_bitcast_i16_16xi1;
         Variable *Src0AsI32 = Func->makeVariable(stackSlotType());
         // Arguments to functions are required to be at least 32 bits wide.
         Context.insert<InstCast>(InstCast::Zext, Src0AsI32, Src0);
         Src0 = Src0AsI32;
       } break;
       }
     } break;
     }
     constexpr SizeT MaxSrcs = 1;
-    InstCall *Call = makeHelperCall(HelperName, CallDest, MaxSrcs);
+    InstCall *Call = makeHelperCall(HelperID, CallDest, MaxSrcs);
     Call->addArg(Src0);
     StackArgumentsSize = getCallStackArgumentsSizeBytes(Call);
     Context.insert(Call);
     // The PNaCl ABI disallows i8/i16 return types, so truncate the helper call
     // result to the appropriate type as necessary.
     if (CallDest->getType() != Dest->getType())
       Context.insert<InstCast>(InstCast::Trunc, Dest, CallDest);
     Cast->setDeleted();
   } else if (auto *Intrinsic = llvm::dyn_cast<InstIntrinsicCall>(Instr)) {
     CfgVector<Type> ArgTypes;
@@ skipping 1016 matching lines @@
         emitGlobal(*Var, SectionSuffix);
       }
     }
   } break;
   }
 }
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H