Cache common constants before lowering.

src/IceTargetLoweringARM32.cpp

 //===- subzero/src/IceTargetLoweringARM32.cpp - ARM32 lowering ------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 450 matching lines @@
         return;
       }
     }
     switch (DestTy) {
     default:
       return;
     case IceType_i64: {
       // Technically, ARM has its own aeabi routines, but we can use the
       // non-aeabi routine as well. LLVM uses __aeabi_ldivmod for div, but uses
       // the more standard __moddi3 for rem.
-      Operand *TargetHelper = nullptr;
+      RuntimeHelperFuncID HelperID = H_Num;
       switch (Op) {
       default:
         return;
       case InstArithmetic::Udiv:
-        TargetHelper = Ctx->getConstantExternSym(H_udiv_i64);
+        HelperID = H_udiv_i64;
         break;
       case InstArithmetic::Sdiv:
-        TargetHelper = Ctx->getConstantExternSym(H_sdiv_i64);
+        HelperID = H_sdiv_i64;
         break;
       case InstArithmetic::Urem:
-        TargetHelper = Ctx->getConstantExternSym(H_urem_i64);
+        HelperID = H_urem_i64;
         break;
       case InstArithmetic::Srem:
-        TargetHelper = Ctx->getConstantExternSym(H_srem_i64);
+        HelperID = H_srem_i64;
         break;
       }
-      assert(TargetHelper != nullptr);
+      Operand *TargetHelper = getRuntimeHelperFunc(HelperID);
       ARM32HelpersPreamble[TargetHelper] = &TargetARM32::preambleDivRem;
       constexpr SizeT MaxArgs = 2;
       auto *Call = Context.insert<InstCall>(MaxArgs, Dest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(Instr->getSrc(0));
       Call->addArg(Instr->getSrc(1));
       Instr->setDeleted();
       return;
     }
     case IceType_i32:
     case IceType_i16:
     case IceType_i8: {
       const bool HasHWDiv = hasCPUFeature(TargetARM32Features::HWDivArm);
       InstCast::OpKind CastKind;
-      Operand *TargetHelper;
+      RuntimeHelperFuncID HelperID = H_Num;
       switch (Op) {
       default:
         return;
       case InstArithmetic::Udiv:
-        TargetHelper =
-            HasHWDiv ? nullptr : Ctx->getConstantExternSym(H_udiv_i32);
+        HelperID = HasHWDiv ? H_Num : H_udiv_i32;
         CastKind = InstCast::Zext;
         break;
       case InstArithmetic::Sdiv:
-        TargetHelper =
-            HasHWDiv ? nullptr : Ctx->getConstantExternSym(H_sdiv_i32);
+        HelperID = HasHWDiv ? H_Num : H_sdiv_i32;
         CastKind = InstCast::Sext;
         break;
       case InstArithmetic::Urem:
-        TargetHelper =
-            HasHWDiv ? nullptr : Ctx->getConstantExternSym(H_urem_i32);
+        HelperID = HasHWDiv ? H_Num : H_urem_i32;
         CastKind = InstCast::Zext;
         break;
       case InstArithmetic::Srem:
-        TargetHelper =
-            HasHWDiv ? nullptr : Ctx->getConstantExternSym(H_srem_i32);
+        HelperID = HasHWDiv ? H_Num : H_srem_i32;
         CastKind = InstCast::Sext;
         break;
       }
-      if (TargetHelper == nullptr) {
-        // TargetHelper should only ever be nullptr when the processor does not
+      if (HelperID == H_Num) {
+        // HelperID should only ever be undefined when the processor does not
         // have a hardware divider. If any other helpers are ever introduced,
         // the following assert will have to be modified.
         assert(HasHWDiv);
         return;
       }
       Operand *Src0 = Instr->getSrc(0);
       Operand *Src1 = Instr->getSrc(1);
       if (DestTy != IceType_i32) {
         // Src0 and Src1 have to be zero-, or signed-extended to i32. For Src0,
         // we just insert a InstCast right before the call to the helper.
@@ skipping 13 matching lines @@
           } else {
             NewC = (NewC << ShAmt) >> ShAmt;
           }
           Src1 = Ctx->getConstantInt32(NewC);
         } else {
           Variable *Src1_32 = Func->makeVariable(IceType_i32);
           Context.insert<InstCast>(CastKind, Src1_32, Src1);
           Src1 = Src1_32;
         }
       }
-      assert(TargetHelper != nullptr);
+      Operand *TargetHelper = getRuntimeHelperFunc(HelperID);
       ARM32HelpersPreamble[TargetHelper] = &TargetARM32::preambleDivRem;
       constexpr SizeT MaxArgs = 2;
       auto *Call = Context.insert<InstCall>(MaxArgs, Dest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       assert(Src0->getType() == IceType_i32);
       Call->addArg(Src0);
       assert(Src1->getType() == IceType_i32);
       Call->addArg(Src1);
       Instr->setDeleted();
       return;
     }
     case IceType_f64:
     case IceType_f32: {
       if (Op != InstArithmetic::Frem) {
         return;
       }
       constexpr SizeT MaxArgs = 2;
-      Operand *TargetHelper = Ctx->getConstantExternSym(
-          DestTy == IceType_f32 ? H_frem_f32 : H_frem_f64);
+      Operand *TargetHelper =
+          getRuntimeHelperFunc(DestTy == IceType_f32 ? H_frem_f32 : H_frem_f64);

[Jim Stichnoth, 2016/03/17 00:14:52]

It seems that TargetLowering::getRuntimeHelperFunc() just proxies to
GlobalContext::getRuntimeHelperFunc().  Can you get rid of the middleman and
directly call the GlobalContext version in all cases?  And remove the proxy
function from TargetLowering?

I assume this is just an artifact of the original implementation approach.

[John, 2016/03/17 14:31:33]

to avoid tons of changes, maybe just add a todo to remove
TargetLowering::getRuntimeHelperFunc()? I don't mind removing it later.

[Karl, 2016/03/17 16:40:53]

See we scoped the enum RuntimeFunctionFuncID, we need to update the files
anyway. Removing.

       auto *Call = Context.insert<InstCall>(MaxArgs, Dest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(Instr->getSrc(0));
       Call->addArg(Instr->getSrc(1));
       Instr->setDeleted();
       return;
     }
     }
     llvm::report_fatal_error("Control flow should never have reached here.");
   }
@@ skipping 19 matching lines @@
     switch (CastKind) {
     default:
       return;
     case InstCast::Fptosi:
     case InstCast::Fptoui: {
       if (DestTy != IceType_i64) {
         return;
       }
       const bool DestIsSigned = CastKind == InstCast::Fptosi;
       const bool Src0IsF32 = isFloat32Asserting32Or64(SrcTy);
-      Operand *TargetHelper = Ctx->getConstantExternSym(
+      Operand *TargetHelper = getRuntimeHelperFunc(
           Src0IsF32 ? (DestIsSigned ? H_fptosi_f32_i64 : H_fptoui_f32_i64)
                     : (DestIsSigned ? H_fptosi_f64_i64 : H_fptoui_f64_i64));
       static constexpr SizeT MaxArgs = 1;
       auto *Call = Context.insert<InstCall>(MaxArgs, Dest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(Src0);
       Instr->setDeleted();
       return;
     }
     case InstCast::Sitofp:
     case InstCast::Uitofp: {
       if (SrcTy != IceType_i64) {
         return;
       }
       const bool SourceIsSigned = CastKind == InstCast::Sitofp;
       const bool DestIsF32 = isFloat32Asserting32Or64(Dest->getType());
-      Operand *TargetHelper = Ctx->getConstantExternSym(
+      Operand *TargetHelper = getRuntimeHelperFunc(
           DestIsF32 ? (SourceIsSigned ? H_sitofp_i64_f32 : H_uitofp_i64_f32)
                     : (SourceIsSigned ? H_sitofp_i64_f64 : H_uitofp_i64_f64));
       static constexpr SizeT MaxArgs = 1;
       auto *Call = Context.insert<InstCall>(MaxArgs, Dest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(Src0);
       Instr->setDeleted();
       return;
     }
     case InstCast::Bitcast: {
       if (DestTy == SrcTy) {
         return;
       }
       Variable *CallDest = Dest;
-      const char *HelperName = nullptr;
+      RuntimeHelperFuncID HelperID = H_Num;
       switch (DestTy) {
       default:
         return;
       case IceType_i8:
         assert(SrcTy == IceType_v8i1);
-        HelperName = H_bitcast_8xi1_i8;
+        HelperID = H_bitcast_8xi1_i8;
         CallDest = Func->makeVariable(IceType_i32);
         break;
       case IceType_i16:
         assert(SrcTy == IceType_v16i1);
-        HelperName = H_bitcast_16xi1_i16;
+        HelperID = H_bitcast_16xi1_i16;
         CallDest = Func->makeVariable(IceType_i32);
         break;
       case IceType_v8i1: {
         assert(SrcTy == 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(SrcTy == 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;
       }
-      assert(HelperName != nullptr);
       constexpr SizeT MaxSrcs = 1;
-      InstCall *Call = makeHelperCall(HelperName, CallDest, MaxSrcs);
+      InstCall *Call = makeHelperCall(HelperID, CallDest, MaxSrcs);
       Call->addArg(Src0);
       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);
       Instr->setDeleted();
       return;
     }
     }
     llvm::report_fatal_error("Control flow should never have reached here.");
   }
   case Inst::IntrinsicCall: {
     Variable *Dest = Instr->getDest();
     auto *IntrinsicCall = llvm::cast<InstIntrinsicCall>(Instr);
     Intrinsics::IntrinsicID ID = IntrinsicCall->getIntrinsicInfo().ID;
     switch (ID) {
     default:
       return;
     case Intrinsics::Ctpop: {
       Operand *Src0 = IntrinsicCall->getArg(0);
-      Operand *TargetHelper = Ctx->getConstantExternSym(
+      Operand *TargetHelper = getRuntimeHelperFunc(
           isInt32Asserting32Or64(Src0->getType()) ? H_call_ctpop_i32
                                                   : H_call_ctpop_i64);
       static constexpr SizeT MaxArgs = 1;
       auto *Call = Context.insert<InstCall>(MaxArgs, Dest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(Src0);
       Instr->setDeleted();
       if (Src0->getType() == IceType_i64) {
         ARM32HelpersPostamble[TargetHelper] = &TargetARM32::postambleCtpop64;
       }
       return;
     }
     case Intrinsics::Longjmp: {
       static constexpr SizeT MaxArgs = 2;
       static constexpr Variable *NoDest = nullptr;
-      Operand *TargetHelper = Ctx->getConstantExternSym(H_call_longjmp);
+      Operand *TargetHelper = getRuntimeHelperFunc(H_call_longjmp);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(IntrinsicCall->getArg(0));
       Call->addArg(IntrinsicCall->getArg(1));
       Instr->setDeleted();
       return;
     }
     case Intrinsics::Memcpy: {
       // In the future, we could potentially emit an inline memcpy/memset, etc.
       // for intrinsic calls w/ a known length.
       static constexpr SizeT MaxArgs = 3;
       static constexpr Variable *NoDest = nullptr;
-      Operand *TargetHelper = Ctx->getConstantExternSym(H_call_memcpy);
+      Operand *TargetHelper = getRuntimeHelperFunc(H_call_memcpy);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(IntrinsicCall->getArg(0));
       Call->addArg(IntrinsicCall->getArg(1));
       Call->addArg(IntrinsicCall->getArg(2));
       Instr->setDeleted();
       return;
     }
     case Intrinsics::Memmove: {
       static constexpr SizeT MaxArgs = 3;
       static constexpr Variable *NoDest = nullptr;
-      Operand *TargetHelper = Ctx->getConstantExternSym(H_call_memmove);
+      Operand *TargetHelper = getRuntimeHelperFunc(H_call_memmove);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(IntrinsicCall->getArg(0));
       Call->addArg(IntrinsicCall->getArg(1));
       Call->addArg(IntrinsicCall->getArg(2));
       Instr->setDeleted();
       return;
     }
     case Intrinsics::Memset: {
       // The value operand needs to be extended to a stack slot size because the
       // PNaCl ABI requires arguments to be at least 32 bits wide.
       Operand *ValOp = IntrinsicCall->getArg(1);
       assert(ValOp->getType() == IceType_i8);
       Variable *ValExt = Func->makeVariable(stackSlotType());
       Context.insert<InstCast>(InstCast::Zext, ValExt, ValOp);
 
       // Technically, ARM has its own __aeabi_memset, but we can use plain
       // memset too. The value and size argument need to be flipped if we ever
       // decide to use __aeabi_memset.
       static constexpr SizeT MaxArgs = 3;
       static constexpr Variable *NoDest = nullptr;
-      Operand *TargetHelper = Ctx->getConstantExternSym(H_call_memset);
+      Operand *TargetHelper = getRuntimeHelperFunc(H_call_memset);
       auto *Call = Context.insert<InstCall>(MaxArgs, NoDest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(IntrinsicCall->getArg(0));
       Call->addArg(ValExt);
       Call->addArg(IntrinsicCall->getArg(2));
       Instr->setDeleted();
       return;
     }
     case Intrinsics::NaClReadTP: {
       if (SandboxingType == ST_NaCl) {
         return;
       }
       static constexpr SizeT MaxArgs = 0;
-      const char *ReadTP =
-          SandboxingType == ST_Nonsfi ? "__aeabi_read_tp" : H_call_read_tp;
-      Operand *TargetHelper = Ctx->getConstantExternSym(ReadTP);
+      Operand *TargetHelper = SandboxingType == ST_Nonsfi
+                                  ? Ctx->getConstantExternSym("__aeabi_read_tp")
+                                  : getRuntimeHelperFunc(H_call_read_tp);
       Context.insert<InstCall>(MaxArgs, Dest, TargetHelper, NoTailCall,
                                IsTargetHelperCall);
       Instr->setDeleted();
       return;
     }
     case Intrinsics::Setjmp: {
       static constexpr SizeT MaxArgs = 1;
-      Operand *TargetHelper = Ctx->getConstantExternSym(H_call_setjmp);
+      Operand *TargetHelper = getRuntimeHelperFunc(H_call_setjmp);
       auto *Call = Context.insert<InstCall>(MaxArgs, Dest, TargetHelper,
                                             NoTailCall, IsTargetHelperCall);
       Call->addArg(IntrinsicCall->getArg(0));
       Instr->setDeleted();
       return;
     }
     }
     llvm::report_fatal_error("Control flow should never have reached here.");
   }
   case Inst::Icmp: {
@@ skipping 6090 matching lines @@
   // However, for compatibility with current NaCl LLVM, don't claim that.
   Str << ".eabi_attribute 14, 3   @ Tag_ABI_PCS_R9_use: Not used\n";
 }
 
 SmallBitVector TargetARM32::TypeToRegisterSet[RegARM32::RCARM32_NUM];
 SmallBitVector TargetARM32::TypeToRegisterSetUnfiltered[RegARM32::RCARM32_NUM];
 SmallBitVector TargetARM32::RegisterAliases[RegARM32::Reg_NUM];
 
 } // end of namespace ARM32
 } // end of namespace Ice