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 6191 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;
+    RuntimeHelperFuncID HelperID = 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 = H_udiv_i64;
         break;
       case InstArithmetic::Sdiv:
-        HelperName = H_sdiv_i64;
+        HelperID = H_sdiv_i64;
         break;
       case InstArithmetic::Urem:
-        HelperName = H_urem_i64;
+        HelperID = H_urem_i64;
         break;
       case InstArithmetic::Srem:
-        HelperName = H_srem_i64;
+        HelperID = 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 = H_frem_f32;
         else
-          HelperName = H_frem_f64;
+          HelperID = 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;
+    RuntimeHelperFuncID HelperID = 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) ? H_fptosi_f32_i64
+                                                     : 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 = 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) ? H_fptoui_f32_i64
+                                                       : H_fptoui_f64_i64;
         } else if (isInt32Asserting32Or64(DestTy)) {
-          HelperName = isFloat32Asserting32Or64(SrcType) ? H_fptoui_f32_i32
-                                                         : H_fptoui_f64_i32;
+          HelperID = isFloat32Asserting32Or64(SrcType) ? H_fptoui_f32_i32
+                                                       : H_fptoui_f64_i32;
         } else {
-          HelperName = isFloat32Asserting32Or64(SrcType) ? H_fptoui_f32_i64
-                                                         : H_fptoui_f64_i64;
+          HelperID = isFloat32Asserting32Or64(SrcType) ? H_fptoui_f32_i64
+                                                       : 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) ? H_sitofp_i64_f32
+                                                    : 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 = 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) ? H_uitofp_i32_f32
+                                                      : H_uitofp_i32_f64;
         } else {
-          HelperName = isFloat32Asserting32Or64(DestTy) ? H_uitofp_i64_f32
-                                                        : H_uitofp_i64_f64;
+          HelperID = isFloat32Asserting32Or64(DestTy) ? H_uitofp_i64_f32
+                                                      : 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 = H_bitcast_8xi1_i8;
         CallDest = Func->makeVariable(IceType_i32);
         break;
       case IceType_i16:
         assert(Src0->getType() == IceType_v16i1);
-        HelperName = H_bitcast_16xi1_i16;
+        HelperID = H_bitcast_16xi1_i16;
         CallDest = Func->makeVariable(IceType_i32);
         break;
       case IceType_v8i1: {
         assert(Src0->getType() == IceType_i8);
-        HelperName = H_bitcast_i8_8xi1;
+        HelperID = 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 = 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