Migrate PrivateMemoryUsageAnalysis to opaque pointers

The original pass used getNonOpaquePtrEltTy to get the element type of
pointer arguments. This is replaced by examining the uses of each
pointer argument to see if they interact with struct types.

Author: michalpaszkowski

IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryUsageAnalysis.cpp

@@ -31,7 +31,6 @@ PrivateMemoryUsageAnalysis::PrivateMemoryUsageAnalysis()
     : ModulePass(ID), m_hasPrivateMem(false)
 {
     initializePrivateMemoryUsageAnalysisPass(*PassRegistry::getPassRegistry());
-
 }
 
 bool PrivateMemoryUsageAnalysis::runOnModule(Module& M)
@@ -45,20 +44,20 @@ bool PrivateMemoryUsageAnalysis::runOnModule(Module& M)
     m_hasDPDivSqrtEmu = !pCtx->platform.hasNoFP64Inst() && !pCtx->platform.hasCorrectlyRoundedMacros() && pCtx->m_DriverInfo.NeedFP64DivSqrt();
 
     // Run on all functions defined in this module
-    for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
+    for (Function &F : M)
     {
-        Function* pFunc = &(*I);
         // Skip functions called from function marked with stackcall attribute
-        if (AddImplicitArgs::hasStackCallInCG(pFunc))
+        if (AddImplicitArgs::hasStackCallInCG(&F))
         {
             hasStackCall = true;
             continue;
         }
-        if (pFunc->isDeclaration())
+        if (F.isDeclaration())
             continue;
-        if (m_pMDUtils->findFunctionsInfoItem(pFunc) == m_pMDUtils->end_FunctionsInfo())
+        if (m_pMDUtils->findFunctionsInfoItem(&F) == m_pMDUtils->end_FunctionsInfo())
             continue;
-        if (runOnFunction(*pFunc))
+
+        if (runOnFunction(F))
         {
             changed = true;
         }
@@ -71,14 +70,13 @@ bool PrivateMemoryUsageAnalysis::runOnModule(Module& M)
         IGC_IS_FLAG_ENABLED(ForceAddingStackcallKernelPrerequisites) ||
         IGC_IS_FLAG_ENABLED(StackOverflowDetection))
     {
-        for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
+        for (Function &F : M)
         {
-            Function* pFunc = &(*I);
-            if (isEntryFunc(m_pMDUtils, pFunc))
+            if (isEntryFunc(m_pMDUtils, &F))
             {
                 SmallVector<ImplicitArg::ArgType, 1> implicitArgs;
                 implicitArgs.push_back(ImplicitArg::PRIVATE_BASE);
-                ImplicitArgs::addImplicitArgs(*pFunc, implicitArgs, m_pMDUtils);
+                ImplicitArgs::addImplicitArgs(F, implicitArgs, m_pMDUtils);
                 changed = true;
             }
         }
@@ -99,27 +97,22 @@ bool PrivateMemoryUsageAnalysis::runOnFunction(Function& F)
     visit(F);
 
     // Struct types always use private memory unless regtomem can
-    // promote them.  Check the function signature to see if any
-    // structs are passesed as arguments.
+    // promote them. Check the function signature to see if any
+    // structs are passed as arguments.
     if (!m_hasPrivateMem)
     {
-        Function::arg_iterator argument = F.arg_begin();
-        for (; argument != F.arg_end(); ++argument)
+        for (auto &Arg : F.args())
         {
-            Argument* arg = &(*argument);
-
-            if (arg->getType()->isPointerTy())
+            if (Arg.hasAttribute(llvm::Attribute::ByVal))
             {
-                Type* type = IGCLLVM::getNonOpaquePtrEltTy(arg->getType());
-
-                if (StructType * structType = dyn_cast<StructType>(type))
-                {
-                    if (!structType->isOpaque())
-                    {
-                        m_hasPrivateMem = true;
-                    }
-                }
+                Type* ByValTy = Arg.getParamByValType();
+                visitType(ByValTy);
+                if (m_hasPrivateMem)
+                    break;
             }
+
+            // Argument uses (which could signal they are of struct type) are
+            // inspected in instruction visitors.
         }
     }
 
@@ -150,6 +143,18 @@ bool PrivateMemoryUsageAnalysis::runOnFunction(Function& F)
     return true;
 }
 
+inline void PrivateMemoryUsageAnalysis::visitType(Type* Ty)
+{
+    // Struct types always use private memory unless regtomem can promote them.
+    if (auto *ST = dyn_cast<StructType>(Ty))
+    {
+        if (!ST->isOpaque())
+        {
+            m_hasPrivateMem = true;
+        }
+    }
+}
+
 void PrivateMemoryUsageAnalysis::visitAllocaInst(llvm::AllocaInst& AI)
 {
     IGC_ASSERT_MESSAGE(AI.getType()->getAddressSpace() == ADDRESS_SPACE_PRIVATE,
@@ -199,4 +204,40 @@ void PrivateMemoryUsageAnalysis::visitCallInst(llvm::CallInst& CI)
             m_hasPrivateMem = true;
         }
     }
+
+    // Check byval arguments for struct usage
+    Function* CalledF = CI.getCalledFunction();
+    if (CalledF)
+    {
+        unsigned ArgNo = 0;
+        for (auto It = CI.arg_begin(), End = CI.arg_end(); It != End; ++It)
+        {
+            if (CI.paramHasAttr(ArgNo, llvm::Attribute::ByVal))
+            {
+                Type* ByValTy = CI.getParamByValType(ArgNo);
+                visitType(ByValTy);
+                if (m_hasPrivateMem)
+                    return;
+            }
+            ArgNo++;
+        }
+    }
+}
+
+void PrivateMemoryUsageAnalysis::visitLoadInst(LoadInst& LI)
+{
+    Type *LoadTy = LI.getType();
+    visitType(LoadTy);
+}
+
+void PrivateMemoryUsageAnalysis::visitStoreInst(StoreInst& SI)
+{
+    Type* ValTy = SI.getValueOperand()->getType();
+    visitType(ValTy);
+}
+
+void PrivateMemoryUsageAnalysis::visitGetElementPtrInst(GetElementPtrInst& GEP)
+{
+    Type *SrcTy = GEP.getSourceElementType();
+    visitType(SrcTy);
 }

IGC/Compiler/Optimizer/OpenCLPasses/PrivateMemory/PrivateMemoryUsageAnalysis.hpp

@@ -66,13 +66,33 @@ namespace IGC
         /// @param  CI The binary op
         void visitCallInst(llvm::CallInst& CI);
 
+        /// @brief  LoadInst instructions visitor.
+        ///         Analyzes if there are struct types loaded.
+        /// @param  LI The load instruction.
+        void visitLoadInst(llvm::LoadInst& LI);
+
+        /// @brief  StoreInst instructions visitor.
+        ///         Analyzes if there are struct types stored.
+        /// @param  SI The store instruction.
+        void visitStoreInst(llvm::StoreInst& SI);
+
+        /// @brief  GetElementPtrInst instructions visitor.
+        ///         Analyzes if there are struct types accessed.
+        /// @param  GEP The GEP instruction.
+        void visitGetElementPtrInst(llvm::GetElementPtrInst& GEP);
+
     private:
         /// @brief  Function entry point.
         ///         Finds all alloca instructions in this function, analyzes them and adds
         ///         private base implicit argument if needed.
         /// @param  F The destination function.
         bool runOnFunction(llvm::Function& F);
 
+        /// @brief  Type visitor.
+        ///         Checks if the type is a non-opaque struct.
+        /// @param  Ty The type to inspect.
+        inline void visitType(llvm::Type* Ty);
+
         /// @brief  A flag signaling if the current function uses private memory
         bool m_hasPrivateMem;