[amdgpu][lds] Use the same isKernel predicate consistently

[JonChesterfield]

Summary

isKernelCC != isKernel(F->getCallingConv())
There's a test case (lower-kernel-lds.ll) that explicitly skips amdgpu_ps
so this change picks the isKernel predicate that continues to skip that
calling convention.

isKernel returns true for AMDGPU_KERNEL and SPIR_KERNEL. isKernelCC also
returns true for other calling conventions.

[arsenm]

Should just delete isKernelCC, it's practically an alias for isModuleEntryFunctionCC

[JonChesterfield]

OK, so this can't be cleanly factored out as in this patch, and the current behaviour is broken for IR which mixes amdgpu_kernel and shaders. LowerModuleLDS groups functions into kernel and non-kernel, and rewrites uses from non-kernels, so if shaders are reclassified as non-kernels (which this patch effectively does) then uses from shaders get rewritten to the function style lowering, which definitely won't work for them.

Difficult to fix accurately if a function is callable from a shader and from a kernel and they use different lowering strategies for LDS. I think I'm going to leave the mixed-uses broken, i.e. ignore this for now, and try to persuade graphics to adopt the same lowering as compute.

llvm/lib/Target/AMDGPU/AMDGPULowerModuleLDSPass.cpp

if (!ModuleScopeVariables.empty()) {
                                     [](Use &) { return true; });
 
       // This ensures the variable is allocated when called functions access it.
       // It also lets other passes, specifically PromoteAlloca, accurately
       // calculate how much LDS will be used by the kernel after lowering.
 
       IRBuilder<> Builder(Ctx);
       for (Function &Func : M.functions()) {
-        if (!Func.isDeclaration() && AMDGPU::isKernelCC(&Func)) {
+        if (!Func.isDeclaration() && AMDGPU::isKernel(Func.getCallingConv())) {
           const CallGraphNode *N = CG[&Func];
           const bool CalleesRequireModuleLDS = N->size() > 0;
 
           if (CalleesRequireModuleLDS) {
             // If a function this kernel might call requires module LDS,
             // annotate the kernel to let later passes know it will allocate
             // this structure, even if not apparent from the IR.
             markUsedByKernel(Builder, &Func, SGV);

llvm/lib/Target/AMDGPU/Utils/AMDGPUMemoryUtils.cpp

static bool shouldLowerLDSToStruct(const GlobalVariable &GV,
   // We are not interested in kernel LDS lowering for module LDS itself.
   if (F && GV.getName() == "llvm.amdgcn.module.lds")
     return false;
 
   bool Ret = false;
   SmallPtrSet<const User *, 8> Visited;
   SmallVector<const User *, 16> Stack(GV.users());
 
-  assert(!F || isKernelCC(F));
+  assert(!F || isKernel(F->getCallingConv()));
 
   while (!Stack.empty()) {
     const User *V = Stack.pop_back_val();
     Visited.insert(V);
 
     if (isa<GlobalValue>(V)) {
       // This use of the LDS variable is the initializer of a global variable.
       // This is ill formed. The address of an LDS variable is kernel dependent
       // and unknown until runtime. It can't be written to a global variable.
       continue;
     }
 
     if (auto *I = dyn_cast<Instruction>(V)) {
       const Function *UF = I->getFunction();
       if (UF == F) {
         // Used from this kernel, we want to put it into the structure.
         Ret = true;
       } else if (!F) {
         // For module LDS lowering, lowering is required if the user instruction
         // is from non-kernel function.
-        Ret |= !isKernelCC(UF);
+        Ret |= !isKernel(UF->getCallingConv());
       }
       continue;
     }
 
     // User V should be a constant, recursively visit users of V.
     assert(isa<Constant>(V) && "Expected a constant.");
     append_range(Stack, V->users());
   }