[ESIMD] Do simd<T, N>* to <N x T> arg/ret type conv when possible. (#6835)

Today, `simd<T, N> foo(simd<T, N> x)` is codegenerated by clang as
   `void foo(simd<T, N>* sret(simd<T, N>) %res, simd<T, N>* %x)`
for the SPIRV target (unless `__regcall` is specified), which is then
converted to
  `void foo(<N x T>* sret(<N x T>) %res, <N x T>* %x)`
in the LowerESIMDVecArg, then to
  `<N x T> foo(<N x T> %x)`
in the VC BE.

With the opaque pointers this becomes impossible, and the optimization
must happen in the "ESIMD FE". This patch implements it.

It also changes `lowerEsimdConstructs` in sycl-post-link.cpp to use new
pass manager to avoid the old pass manager-related boiler plate code in
new ESIMD transformations.

Signed-off-by: Konstantin S Bobrovsky <[email protected]>

Author: kbobrovs

llvm/include/llvm/SYCLLowerIR/ESIMD/ESIMDUtils.h

@@ -8,6 +8,7 @@
 // Utility functions for processing ESIMD code.
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/IR/Function.h"
 
 #include <functional>
@@ -19,24 +20,40 @@ constexpr char ATTR_DOUBLE_GRF[] = "esimd-double-grf";
 constexpr char ESIMD_MARKER_MD[] = "sycl_explicit_simd";
 
 using CallGraphNodeAction = std::function<void(Function *)>;
-void traverseCallgraphUp(llvm::Function *F, CallGraphNodeAction NodeF,
-                         bool ErrorOnNonCallUse);
 
 // Traverses call graph starting from given function up the call chain applying
 // given action to each function met on the way. If \c ErrorOnNonCallUse
 // parameter is true, then no functions' uses are allowed except calls.
 // Otherwise, any function where use of the current one happened is added to the
 // call graph as if the use was a call.
+// Functions which are part of the visited set ('Visited' parameter) are not
+// traversed.
+void traverseCallgraphUp(llvm::Function *F, CallGraphNodeAction NodeF,
+                         SmallPtrSetImpl<Function *> &Visited,
+                         bool ErrorOnNonCallUse);
+
+template <class CallGraphNodeActionF>
+void traverseCallgraphUp(Function *F, CallGraphNodeActionF ActionF,
+                         SmallPtrSetImpl<Function *> &Visited,
+                         bool ErrorOnNonCallUse) {
+  traverseCallgraphUp(F, CallGraphNodeAction(ActionF), Visited,
+                      ErrorOnNonCallUse);
+}
+
 template <class CallGraphNodeActionF>
 void traverseCallgraphUp(Function *F, CallGraphNodeActionF ActionF,
                          bool ErrorOnNonCallUse = true) {
-  traverseCallgraphUp(F, CallGraphNodeAction{ActionF}, ErrorOnNonCallUse);
+  SmallPtrSet<Function *, 32> Visited;
+  traverseCallgraphUp(F, CallGraphNodeAction(ActionF), Visited,
+                      ErrorOnNonCallUse);
 }
 
 // Tells whether given function is a ESIMD kernel.
 bool isESIMDKernel(const Function &F);
 // Tells whether given function is a ESIMD function.
 bool isESIMD(const Function &F);
+// Tells whether given function is a kernel.
+bool isKernel(const Function &F);
 
 /// Reports and error with the message \p Msg concatenated with the optional
 /// \p OptMsg if \p Condition is false.
@@ -48,5 +65,22 @@ inline void assert_and_diag(bool Condition, StringRef Msg,
   }
 }
 
+/// Tells if this value is a bit cast or address space cast.
+bool isCast(const Value *V);
+
+/// Climbs up the use-def chain of given value until a value which is not a
+/// bit cast or address space cast is met.
+const Value *stripCasts(const Value *V);
+Value *stripCasts(Value *V);
+
+/// Collects uses of given value "looking through" casts. I.e. if a use is a
+/// cast (chain), then uses of the result of the cast (chain) are collected.
+void collectUsesLookThroughCasts(const Value *V,
+                                 SmallPtrSetImpl<const Use *> &Uses);
+
+/// Unwraps a presumably simd* type to extract the native vector type encoded
+/// in it. Returns nullptr if failed to do so.
+Type *getVectorTyOrNull(StructType *STy);
+
 } // namespace esimd
 } // namespace llvm

llvm/include/llvm/SYCLLowerIR/ESIMD/LowerESIMD.h

@@ -69,6 +69,17 @@ class ESIMDLowerVecArgPass : public PassInfoMixin<ESIMDLowerVecArgPass> {
 ModulePass *createESIMDLowerVecArgPass();
 void initializeESIMDLowerVecArgLegacyPassPass(PassRegistry &);
 
+// - Converts simd* function parameters and return values passed by pointer to
+// pass-by-value
+//   (where possible)
+// - Converts globals of type simd* to simd::raw_vector_t* globals (llvm vector
+// type pointer)
+class ESIMDOptimizeVecArgCallConvPass
+    : public PassInfoMixin<ESIMDOptimizeVecArgCallConvPass> {
+public:
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
+};
+
 // Lowers calls to __esimd_set_kernel_properties
 class SYCLLowerESIMDKernelPropsPass
     : public PassInfoMixin<SYCLLowerESIMDKernelPropsPass> {

llvm/lib/Passes/PassRegistry.def

@@ -129,6 +129,7 @@ MODULE_PASS("pseudo-probe-update", PseudoProbeUpdatePass())
 MODULE_PASS("LowerESIMD", SYCLLowerESIMDPass())
 MODULE_PASS("lower-esimd-kernel-props", SYCLLowerESIMDKernelPropsPass())
 MODULE_PASS("ESIMDLowerVecArg", ESIMDLowerVecArgPass())
+MODULE_PASS("esimd-opt-call-conv", ESIMDOptimizeVecArgCallConvPass())
 MODULE_PASS("esimd-verifier", ESIMDVerifierPass())
 MODULE_PASS("lower-invoke-simd", SYCLLowerInvokeSimdPass())
 MODULE_PASS("SYCLMutatePrintfAddrspace", SYCLMutatePrintfAddrspacePass())

llvm/lib/SYCLLowerIR/CMakeLists.txt

@@ -54,6 +54,7 @@ add_llvm_component_library(LLVMSYCLLowerIR
   ESIMD/ESIMDUtils.cpp
   ESIMD/ESIMDVerifier.cpp
   ESIMD/LowerESIMDKernelAttrs.cpp
+  ESIMD/ESIMDOptimizeVecArgCallConv.cpp
   LowerInvokeSimd.cpp
   LowerWGScope.cpp
   LowerWGLocalMemory.cpp