[Polly] Simplify the implementation of getCUDALibDeviceFunction. NFC.

[philip.pfaffe]

Summary

The function is currently awfully complicated. Drop the IILE and use
StringRef over std::string.

[Meinersbur]

Why was there a lambda in the first place?

lib/CodeGen/PPCGCodeGeneration.cpp

1413 ↗

(On Diff #150918)

[style] I'd prefer to avoid this kind of recursion.

polly/trunk/lib/CodeGen/PPCGCodeGeneration.cpp

 
 // A map from intrinsics to their corresponding libdevice functions.
 const std::map<std::string, std::string> IntrinsicToLibdeviceFunc = {
     {"llvm.exp.f64", "exp"},
     {"llvm.exp.f32", "expf"},
     {"llvm.powi.f64", "powi"},
     {"llvm.powi.f32", "powif"}};
 
-/// Return the corresponding CUDA libdevice function name for @p F.
+/// Return the corresponding CUDA libdevice function name @p Name.
 /// Note that this function will try to convert instrinsics in the list
 /// IntrinsicToLibdeviceFunc into libdevice functions.
 /// This is because some intrinsics such as `exp`
 /// are not supported by the NVPTX backend.
 /// If this restriction of the backend is lifted, we should refactor our code
 /// so that we use intrinsics whenever possible.
 ///
 /// Return "" if we are not compiling for CUDA.
-std::string getCUDALibDeviceFuntion(Function *F) {
-  auto FnName = [&]() -> const std::string {
-    auto It = IntrinsicToLibdeviceFunc.find(F->getName());
-    if (It != IntrinsicToLibdeviceFunc.end())
-      return It->second;
+std::string getCUDALibDeviceFuntion(StringRef Name) {
+  auto It = IntrinsicToLibdeviceFunc.find(Name);
+    return getCUDALibDeviceFuntion(It->second);
 
-    return std::string(F->getName());
-  }();
-
-  if (CUDALibDeviceFunctions.count(FnName))
-    return "__nv_" + FnName;
+  if (CUDALibDeviceFunctions.count(Name))
+    return ("__nv_" + Name).str();
 
   return "";
 }
 
 /// Check if F is a function that we can code-generate in a GPU kernel.
 static bool isValidFunctionInKernel(llvm::Function *F, bool AllowLibDevice) {
   assert(F && "F is an invalid pointer");
   // We string compare against the name of the function to allow
   // all variants of the intrinsic "llvm.sqrt.*", "llvm.fabs", and
   // "llvm.copysign".
   const StringRef Name = F->getName();
 
-  if (AllowLibDevice && getCUDALibDeviceFuntion(F).length() > 0)
+  if (AllowLibDevice && getCUDALibDeviceFuntion(Name).length() > 0)
     return true;
 
   return F->isIntrinsic() &&
          (Name.startswith("llvm.sqrt") || Name.startswith("llvm.fabs") ||
           Name.startswith("llvm.copysign"));
 }
 
 /// Do not take `Function` as a subtree value.

 }
 
 bool GPUNodeBuilder::requiresCUDALibDevice() {
   bool RequiresLibDevice = false;
   for (Function &F : GPUModule->functions()) {
     if (!F.isDeclaration())
       continue;
 
-    const std::string CUDALibDeviceFunc = getCUDALibDeviceFuntion(&F);
+    const std::string CUDALibDeviceFunc = getCUDALibDeviceFuntion(F.getName());
     if (CUDALibDeviceFunc.length() != 0) {
       // We need to handle the case where a module looks like this:
       // @expf(..)
       // @llvm.exp.f64(..)
       // Both of these functions would be renamed to `__nv_expf`.
       //
       // So, we must first check for the existence of the libdevice function.
       // If this exists, we replace our current function with it.