[SYCL] Improve output emitted in opt-report

clang/include/clang/Basic/SyclOptReportHandler.h

@@ -25,21 +25,31 @@ class FunctionDecl;
 class SyclOptReportHandler {
 private:
   struct OptReportInfo {
-    std::string KernelArgName;
+    std::string KernelArgDescName; // Kernel argument name itself, or the name
+                                   // of the parent class if the kernel argument
+                                   // is a decomposed member.
     std::string KernelArgType;
     SourceLocation KernelArgLoc;
+    unsigned KernelArgSize;
+    std::string KernelArgDesc;
+    std::string KernelArgDecomposedField;
 
-    OptReportInfo(std::string ArgName, std::string ArgType,
-                  SourceLocation ArgLoc)
-        : KernelArgName(std::move(ArgName)), KernelArgType(std::move(ArgType)),
-          KernelArgLoc(ArgLoc) {}
+    OptReportInfo(std::string ArgDescName, std::string ArgType,
+                  SourceLocation ArgLoc, unsigned ArgSize, std::string ArgDesc,
+                  std::string ArgDecomposedField)
+        : KernelArgDescName(std::move(ArgDescName)),
+          KernelArgType(std::move(ArgType)), KernelArgLoc(ArgLoc),
+          KernelArgSize(ArgSize), KernelArgDesc(std::move(ArgDesc)),
+          KernelArgDecomposedField(std::move(ArgDecomposedField)) {}
   };
   llvm::DenseMap<const FunctionDecl *, SmallVector<OptReportInfo>> Map;
 
 public:
-  void AddKernelArgs(const FunctionDecl *FD, std::string ArgName,
-                     std::string ArgType, SourceLocation ArgLoc) {
-    Map[FD].emplace_back(ArgName, ArgType, ArgLoc);
+  void AddKernelArgs(const FunctionDecl *FD, StringRef ArgDescName,
+                     StringRef ArgType, SourceLocation ArgLoc, unsigned ArgSize,
+                     StringRef ArgDesc, StringRef ArgDecomposedField) {
+    Map[FD].emplace_back(ArgDescName.data(), ArgType.data(), ArgLoc, ArgSize,
+                         ArgDesc.data(), ArgDecomposedField.data());
   }
   SmallVector<OptReportInfo> &GetInfo(const FunctionDecl *FD) {
     auto It = Map.find(FD);

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -1518,14 +1518,18 @@ void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
     for (auto ORI : llvm::enumerate(OptReportHandler.GetInfo(FD))) {
       llvm::DiagnosticLocation DL =
           SourceLocToDebugLoc(ORI.value().KernelArgLoc);
-      std::string KAN = ORI.value().KernelArgName;
+      StringRef NameInDesc = ORI.value().KernelArgDescName;
+      StringRef ArgType = ORI.value().KernelArgType;
+      StringRef ArgDesc = ORI.value().KernelArgDesc;
+      unsigned ArgSize = ORI.value().KernelArgSize;
+      StringRef ArgDecomposedField = ORI.value().KernelArgDecomposedField;
+
       llvm::OptimizationRemark Remark("sycl", "Region", DL,
                                       &Fn->getEntryBlock());
-      Remark << "Argument " << llvm::ore::NV("Argument", ORI.index())
-             << " for function kernel: "
-             << llvm::ore::NV(KAN.empty() ? "&" : "") << " " << Fn->getName()
-             << "." << llvm::ore::NV(KAN.empty() ? " " : KAN) << "("
-             << ORI.value().KernelArgType << ")";
+      Remark << "Arg " << llvm::ore::NV("Argument", ORI.index()) << ":"
+             << ArgDesc << NameInDesc << "  (" << ArgDecomposedField
+             << "Type:" << ArgType << ", "
+             << "Size: " << llvm::ore::NV("Argument", ArgSize) << ")";
       ORE.emit(Remark);
     }
   }

clang/lib/Sema/SemaSYCL.cpp

@@ -1768,9 +1768,6 @@ class SyclKernelDeclCreator : public SyclKernelFieldHandler {
 
   void addParam(const FieldDecl *FD, QualType FieldTy) {
     ParamDesc newParamDesc = makeParamDesc(FD, FieldTy);
-    SemaRef.getDiagnostics().getSYCLOptReportHandler().AddKernelArgs(
-        KernelDecl, FD->getName().data(), FieldTy.getAsString(),
-        FD->getLocation());
     addParam(newParamDesc, FieldTy);
   }
 
@@ -1781,8 +1778,6 @@ class SyclKernelDeclCreator : public SyclKernelFieldHandler {
     StringRef Name = "_arg__base";
     ParamDesc newParamDesc =
         makeParamDesc(SemaRef.getASTContext(), Name, FieldTy);
-    SemaRef.getDiagnostics().getSYCLOptReportHandler().AddKernelArgs(
-        KernelDecl, "", FieldTy.getAsString(), BS.getBaseTypeLoc());
     addParam(newParamDesc, FieldTy);
   }
   // Add a parameter with specified name and type
@@ -2230,6 +2225,216 @@ class SyclKernelArgsSizeChecker : public SyclKernelFieldHandler {
   using SyclKernelFieldHandler::handleSyclHalfType;
 };
 
+enum class KernelArgDescription {
+  BaseClass,
+  DecomposedMember,
+  WrappedPointer,
+  WrappedArray,
+  Accessor,
+  AccessorBase,
+  Sampler,
+  Stream,
+  KernelHandler,
+  None
+};
+
+StringRef getKernelArgDesc(KernelArgDescription Desc) {
+  switch (Desc) {
+  case KernelArgDescription::BaseClass:
+    return "Compiler generated argument for base class,";
+  case KernelArgDescription::DecomposedMember:
+    return "Compiler generated argument for decomposed struct/class,";
+  case KernelArgDescription::WrappedPointer:
+    return "Compiler generated argument for nested pointer,";
+  case KernelArgDescription::WrappedArray:
+    return "Compiler generated argument for array,";
+  case KernelArgDescription::Accessor:
+    return "Compiler generated argument for accessor,";
+  case KernelArgDescription::AccessorBase:
+    return "Compiler generated argument for accessor base class,";
+  case KernelArgDescription::Sampler:
+    return "Compiler generated argument for sampler,";
+  case KernelArgDescription::Stream:
+    return "Compiler generated argument for stream,";
+  case KernelArgDescription::KernelHandler:
+    return "Compiler generated argument for SYCL2020 specialization constant";
+  case KernelArgDescription::None:
+    return "";
+  }
+  llvm_unreachable(
+      "switch should cover all possible values for KernelArgDescription");
+}
+
+class SyclOptReportCreator : public SyclKernelFieldHandler {
+  SyclKernelDeclCreator &DC;
+  SourceLocation KernelInvocationLoc;
+
+  void addParam(const FieldDecl *KernelArg, QualType KernelArgType,
+                KernelArgDescription KernelArgDesc) {
+    StringRef NameToEmitInDescription = KernelArg->getName();
+    const RecordDecl *KernelArgParent = KernelArg->getParent();
+    if (KernelArgParent &&
+        KernelArgDesc == KernelArgDescription::DecomposedMember) {
+      NameToEmitInDescription = KernelArgParent->getName();
+    }
+
+    bool isWrappedField =
+        KernelArgDesc == KernelArgDescription::WrappedPointer ||
+        KernelArgDesc == KernelArgDescription::WrappedArray;
+
+    unsigned KernelArgSize =
+        SemaRef.getASTContext().getTypeSizeInChars(KernelArgType).getQuantity();
+
+    SemaRef.getDiagnostics().getSYCLOptReportHandler().AddKernelArgs(
+        DC.getKernelDecl(), NameToEmitInDescription,
+        isWrappedField ? "Compiler generated" : KernelArgType.getAsString(),
+        KernelInvocationLoc, KernelArgSize, getKernelArgDesc(KernelArgDesc),
+        (KernelArgDesc == KernelArgDescription::DecomposedMember)
+            ? ("Field:" + KernelArg->getName().str() + ", ")
+            : "");
+  }
+
+  void addParam(const FieldDecl *FD, QualType FieldTy) {
+    KernelArgDescription Desc = KernelArgDescription::None;
+    const RecordDecl *RD = FD->getParent();
+    if (RD && RD->hasAttr<SYCLRequiresDecompositionAttr>())
+      Desc = KernelArgDescription::DecomposedMember;
+
+    addParam(FD, FieldTy, Desc);
+  }
+
+  // Handles base classes.
+  void addParam(const CXXBaseSpecifier &, QualType KernelArgType,
+                KernelArgDescription KernelArgDesc) {
+    unsigned KernelArgSize =
+        SemaRef.getASTContext().getTypeSizeInChars(KernelArgType).getQuantity();
+    SemaRef.getDiagnostics().getSYCLOptReportHandler().AddKernelArgs(
+        DC.getKernelDecl(), KernelArgType.getAsString(),
+        KernelArgType.getAsString(), KernelInvocationLoc, KernelArgSize,
+        getKernelArgDesc(KernelArgDesc), "");
+  }
+
+  // Handles specialization constants.
+  void addParam(QualType KernelArgType, KernelArgDescription KernelArgDesc) {
+    unsigned KernelArgSize =
+        SemaRef.getASTContext().getTypeSizeInChars(KernelArgType).getQuantity();
+    SemaRef.getDiagnostics().getSYCLOptReportHandler().AddKernelArgs(
+        DC.getKernelDecl(), "", KernelArgType.getAsString(),
+        KernelInvocationLoc, KernelArgSize, getKernelArgDesc(KernelArgDesc),
+        "");
+  }
+
+  // Handles SYCL special types (accessor, sampler and stream) and modified
+  // types (arrays and pointers)
+  bool handleSpecialType(const FieldDecl *FD, QualType FieldTy,
+                         KernelArgDescription Desc) {
+    for (const auto *Param : DC.getParamVarDeclsForCurrentField())
+      addParam(FD, Param->getType(), Desc);
+    return true;
+  }
+
+public:
+  static constexpr const bool VisitInsideSimpleContainers = false;
+  SyclOptReportCreator(Sema &S, SyclKernelDeclCreator &DC, SourceLocation Loc)
+      : SyclKernelFieldHandler(S), DC(DC), KernelInvocationLoc(Loc) {}
+
+  bool handleSyclAccessorType(FieldDecl *FD, QualType FieldTy) final {
+    return handleSpecialType(
+        FD, FieldTy, KernelArgDescription(KernelArgDescription::Accessor));
+  }
+
+  bool handleSyclAccessorType(const CXXRecordDecl *, const CXXBaseSpecifier &BS,
+                              QualType FieldTy) final {
+    for (const auto *Param : DC.getParamVarDeclsForCurrentField()) {
+      QualType KernelArgType = Param->getType();
+      unsigned KernelArgSize = SemaRef.getASTContext()
+                                   .getTypeSizeInChars(KernelArgType)
+                                   .getQuantity();
+      SemaRef.getDiagnostics().getSYCLOptReportHandler().AddKernelArgs(
+          DC.getKernelDecl(), FieldTy.getAsString(),
+          KernelArgType.getAsString(), KernelInvocationLoc, KernelArgSize,
+          getKernelArgDesc(
+              KernelArgDescription(KernelArgDescription::AccessorBase)),
+          "");
+    }
+    return true;
+  }
+
+  bool handleSyclSamplerType(FieldDecl *FD, QualType FieldTy) final {
+    return handleSpecialType(
+        FD, FieldTy, KernelArgDescription(KernelArgDescription::Sampler));
+  }
+
+  bool handlePointerType(FieldDecl *FD, QualType FieldTy) final {
+    KernelArgDescription Desc = KernelArgDescription::None;
+    ParmVarDecl *KernelParameter = DC.getParamVarDeclsForCurrentField()[0];
+    // Compiler generated openCL kernel argument for current pointer field
+    // is not a pointer. This means we are processing a nested pointer and
+    // the openCL kernel argument is of type __wrapper_class.
+    if (!KernelParameter->getType()->isPointerType())
+      Desc = KernelArgDescription::WrappedPointer;
+    return handleSpecialType(FD, FieldTy, Desc);
+  }
+
+  bool handleScalarType(FieldDecl *FD, QualType FieldTy) final {
+    addParam(FD, FieldTy);
+    return true;
+  }
+
+  bool handleSimpleArrayType(FieldDecl *FD, QualType FieldTy) final {
+    // Simple arrays are always wrapped.
+    handleSpecialType(FD, FieldTy,
+                      KernelArgDescription(KernelArgDescription::WrappedArray));
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *, FieldDecl *FD,
+                             QualType Ty) final {
+    addParam(FD, Ty);
+    return true;
+  }
+
+  bool handleNonDecompStruct(const CXXRecordDecl *Base,
+                             const CXXBaseSpecifier &BS, QualType Ty) final {
+    addParam(BS, Ty, KernelArgDescription(KernelArgDescription::BaseClass));
+    return true;
+  }
+
+  bool handleUnionType(FieldDecl *FD, QualType FieldTy) final {
+    return handleScalarType(FD, FieldTy);
+  }
+
+  bool handleSyclHalfType(FieldDecl *FD, QualType FieldTy) final {
+    addParam(FD, FieldTy);
+    return true;
+  }
+
+  bool handleSyclStreamType(FieldDecl *FD, QualType FieldTy) final {
+    // For the current implementation of stream class, the Visitor 'handles'
+    // stream argument and then visits each accessor field in stream. Therefore
+    // handleSpecialType in this case only adds a single argument for stream.
+    // The arguments corresponding to accessors in stream are handled in
+    // handleSyclAccessorType. The opt-report therefore does not diffrentiate
+    // between the accessors in streams and accessors captured by SYCL kernel.
+    // Once stream API is modified to use __init(), the visitor will no longer
+    // visit the stream object and opt-report output for stream class will be
+    // similar to that of other special types.
+    return handleSpecialType(
+        FD, FieldTy, KernelArgDescription(KernelArgDescription::Stream));
+  }
+
+  void handleSyclKernelHandlerType() {
+    ASTContext &Context = SemaRef.getASTContext();
+    if (isDefaultSPIRArch(Context))
+      return;
+    addParam(DC.getParamVarDeclsForCurrentField()[0]->getType(),
+             KernelArgDescription(KernelArgDescription::KernelHandler));
+  }
+  using SyclKernelFieldHandler::handleSyclHalfType;
+  using SyclKernelFieldHandler::handleSyclSamplerType;
+  using SyclKernelFieldHandler::handleSyclStreamType;
+};
+
 static CXXMethodDecl *getOperatorParens(const CXXRecordDecl *Rec) {
   for (auto *MD : Rec->methods()) {
     if (MD->getOverloadedOperator() == OO_Call)
@@ -3552,18 +3757,20 @@ void Sema::ConstructOpenCLKernel(FunctionDecl *KernelCallerFunc,
       StableName, KernelCallerFunc);
 
   SyclKernelIntFooterCreator int_footer(*this, getSyclIntegrationFooter());
+  SyclOptReportCreator opt_report(*this, kernel_decl, KernelObj->getLocation());
 
   KernelObjVisitor Visitor{*this};
   Visitor.VisitRecordBases(KernelObj, kernel_decl, kernel_body, int_header,
-                           int_footer);
+                           int_footer, opt_report);
   Visitor.VisitRecordFields(KernelObj, kernel_decl, kernel_body, int_header,
-                            int_footer);
+                            int_footer, opt_report);
 
   if (ParmVarDecl *KernelHandlerArg =
           getSyclKernelHandlerArg(KernelCallerFunc)) {
     kernel_decl.handleSyclKernelHandlerType();
     kernel_body.handleSyclKernelHandlerType(KernelHandlerArg);
     int_header.handleSyclKernelHandlerType(KernelHandlerArg->getType());
+    opt_report.handleSyclKernelHandlerType();
   }
 }