[Polly] [PPCGCodeGeneration] Convert intrinsics to libdevice functions whenever possible.

[bollu]

Summary

This is useful when we face certain intrinsics such as llvm.exp.*
which cannot be lowered by the NVPTX backend while other intrinsics can.

So, we would need to keep blacklists of intrinsics that cannot be
handled by the NVPTX backend. It is much simpler to try and promote
all intrinsics to libdevice versions.

This patch makes function/intrinsic very uniform, and will always try to use
a libdevice version if it exists.

[bollu]

• [Bugfix] add powi to the list of instructions that the NVPTX backend cannot lower.
• [NFC] remove debug code

[bollu]

I should probably split this into two patches, but I wanted to run the idea by. I can split it when I commit (or split it now). Review, please.

[bollu]

• [Test] upadte tests to refect state of exp, powi in PPCGCodeGen

[efriedma]

Why can't the LLVM NVPTX backend handle these intrinsics? If implementations are available, the backend should call them. Or am I missing something obvious?

[bollu]

@efriedma - The NVPTX backend does not lower either llvm.exp.* or llvm.powi.* (Unless I am doing something wrong).

[efriedma]

Hmm, looks like it doesn't work (I get "LLVM ERROR: Cannot select: t14: i32 = ExternalSymbol'__powisf2'"). But that's clearly a bug in the backend rather than something you should try to address in polly.

[bollu]

@grosser ping, review please.

[grosser]

Hi Eli,

you are right. It would be nice if the backend would directly include libdevice. There is some information about libdevice available at https://llvm.org/docs/NVPTXUsage.html#linking-with-libdevice, but it seems it is indeed expected to be linked before things are passed to the LLVM backend.

Siddharth, can you please open a bug report regarding the issue Eli mentioned? Eli, do you think it is OK to move ahead for now, until this issue has been solved in the LLVM backend. (We are happy to add the necessary code, but this likely first needs some discussion.) Siddharth, maybe you can even open a discussion on llvm-dev?

Best,
Tobias

[efriedma]

Yes, it's okay for now.

lib/CodeGen/PPCGCodeGeneration.cpp

1420

Instead of trying to parse the name of the intrinsic, could you just map from an exact llvm intrinsic name to the equivalent libdevice function? e.g. map llvm.powi.f32 to __nv_powif, llvm.powi.f64 to __nv_powi, etc.

[bollu]

• Don't parse the function name, keep a static map from intrinsic names to libdevice names

[bollu]

• [Diff update] Update diff with latest master.

[bollu]

@efriedma I made the changes you requested. Could you have a final look, please?

[efriedma]

LGTM

lib/CodeGen/PPCGCodeGeneration.cpp

isl_bool collectReferencesInGPUStmt(__isl_keep isl_ast_node *Node, void *User) {
 
   addReferencesFromStmt(Stmt, User, false /* CreateScalarRefs */);
 
   return isl_bool_true;
 }
 
 /// A list of functions that are available in NVIDIA's libdevice.
 const std::set<std::string> CUDALibDeviceFunctions = {
-    "exp",   "expf",     "expl",      "cos",       "cosf", "sqrt",
-    "sqrtf", "copysign", "copysignf", "copysignl", "log",  "logf"};
+    "exp",      "expf",      "expl",      "cos", "cosf", "sqrt", "sqrtf",
+    "copysign", "copysignf", "copysignl", "log", "logf", "powi"};
+
+/// A list of intrinsics that are unsupported by the NVPTX backend.
+const std::set<std::string> NVPTXUnsupportedIntrinsics = {"exp", "powi"};
+
+/// Return <intrinsicname> from the full  "llvm.<intrinsicname>.<ty>" name.
+///
+/// Return "" if function is not an intrinsic.
+std::string getStrippedIntrinsicName(const Function *F) {
+  assert(F && "invalid function pointer");
+  const StringRef FnName = F->getName();
+
+  if (F->isIntrinsic() && FnName.startswith("llvm.")) {
+    const size_t BeginSeparator = FnName.find(".");
+    const size_t EndSeparator = FnName.rfind(".");
+    return std::string(FnName.slice(BeginSeparator + 1, EndSeparator));
+  }
+  return "";
+}
 
 /// Return the corresponding CUDA libdevice function name for @p F.
+/// Note that this function will try to convert instrinsics in the list
+/// NVPTXUnsupportedIntrinsics 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) {
-  if (CUDALibDeviceFunctions.count(F->getName()))
-    return std::string("__nv_") + std::string(F->getName());
+  const std::string FnName = [&] {
+    const std::string IntrinsicName = getStrippedIntrinsicName(F);
+    if (NVPTXUnsupportedIntrinsics.count(IntrinsicName))
+      return IntrinsicName;
+
+    return std::string(F->getName());
+  }();
+
+  if (CUDALibDeviceFunctions.count(FnName))
+    return "__nv_" + FnName;
 
   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)
     return true;
 
   return F->isIntrinsic() &&
          (Name.startswith("llvm.sqrt") || Name.startswith("llvm.fabs") ||
-          Name.startswith("llvm.copysign") || Name.startswith("llvm.powi"));
+          Name.startswith("llvm.copysign"));
 }
 
 /// Do not take `Function` as a subtree value.
 ///
 /// We try to take the reference of all subtree values and pass them along
 /// to the kernel from the host. Taking an address of any function and
 /// trying to pass along is nonsensical. Only allow `Value`s that are not
 /// `Function`s.