@@ -1777,9 +1777,6 @@ class SyclKernelDeclCreator : public SyclKernelFieldHandler {
1777
1777
1778
1778
void addParam (const FieldDecl *FD, QualType FieldTy) {
1779
1779
ParamDesc newParamDesc = makeParamDesc (FD, FieldTy);
1780
- SemaRef.getDiagnostics ().getSYCLOptReportHandler ().AddKernelArgs (
1781
- KernelDecl, FD->getName ().data (), FieldTy.getAsString (),
1782
- FD->getLocation ());
1783
1780
addParam (newParamDesc, FieldTy);
1784
1781
}
1785
1782
@@ -1790,8 +1787,6 @@ class SyclKernelDeclCreator : public SyclKernelFieldHandler {
1790
1787
StringRef Name = " _arg__base" ;
1791
1788
ParamDesc newParamDesc =
1792
1789
makeParamDesc (SemaRef.getASTContext (), Name, FieldTy);
1793
- SemaRef.getDiagnostics ().getSYCLOptReportHandler ().AddKernelArgs (
1794
- KernelDecl, " " , FieldTy.getAsString (), BS.getBaseTypeLoc ());
1795
1790
addParam (newParamDesc, FieldTy);
1796
1791
}
1797
1792
// Add a parameter with specified name and type
@@ -2239,6 +2234,216 @@ class SyclKernelArgsSizeChecker : public SyclKernelFieldHandler {
2239
2234
using SyclKernelFieldHandler::handleSyclHalfType;
2240
2235
};
2241
2236
2237
+ enum class KernelArgDescription {
2238
+ BaseClass,
2239
+ DecomposedMember,
2240
+ WrappedPointer,
2241
+ WrappedArray,
2242
+ Accessor,
2243
+ AccessorBase,
2244
+ Sampler,
2245
+ Stream,
2246
+ KernelHandler,
2247
+ None
2248
+ };
2249
+
2250
+ StringRef getKernelArgDesc (KernelArgDescription Desc) {
2251
+ switch (Desc) {
2252
+ case KernelArgDescription::BaseClass:
2253
+ return " Compiler generated argument for base class," ;
2254
+ case KernelArgDescription::DecomposedMember:
2255
+ return " Compiler generated argument for decomposed struct/class," ;
2256
+ case KernelArgDescription::WrappedPointer:
2257
+ return " Compiler generated argument for nested pointer," ;
2258
+ case KernelArgDescription::WrappedArray:
2259
+ return " Compiler generated argument for array," ;
2260
+ case KernelArgDescription::Accessor:
2261
+ return " Compiler generated argument for accessor," ;
2262
+ case KernelArgDescription::AccessorBase:
2263
+ return " Compiler generated argument for accessor base class," ;
2264
+ case KernelArgDescription::Sampler:
2265
+ return " Compiler generated argument for sampler," ;
2266
+ case KernelArgDescription::Stream:
2267
+ return " Compiler generated argument for stream," ;
2268
+ case KernelArgDescription::KernelHandler:
2269
+ return " Compiler generated argument for SYCL2020 specialization constant" ;
2270
+ case KernelArgDescription::None:
2271
+ return " " ;
2272
+ }
2273
+ llvm_unreachable (
2274
+ " switch should cover all possible values for KernelArgDescription" );
2275
+ }
2276
+
2277
+ class SyclOptReportCreator : public SyclKernelFieldHandler {
2278
+ SyclKernelDeclCreator &DC;
2279
+ SourceLocation KernelInvocationLoc;
2280
+
2281
+ void addParam (const FieldDecl *KernelArg, QualType KernelArgType,
2282
+ KernelArgDescription KernelArgDesc) {
2283
+ StringRef NameToEmitInDescription = KernelArg->getName ();
2284
+ const RecordDecl *KernelArgParent = KernelArg->getParent ();
2285
+ if (KernelArgParent &&
2286
+ KernelArgDesc == KernelArgDescription::DecomposedMember) {
2287
+ NameToEmitInDescription = KernelArgParent->getName ();
2288
+ }
2289
+
2290
+ bool isWrappedField =
2291
+ KernelArgDesc == KernelArgDescription::WrappedPointer ||
2292
+ KernelArgDesc == KernelArgDescription::WrappedArray;
2293
+
2294
+ unsigned KernelArgSize =
2295
+ SemaRef.getASTContext ().getTypeSizeInChars (KernelArgType).getQuantity ();
2296
+
2297
+ SemaRef.getDiagnostics ().getSYCLOptReportHandler ().AddKernelArgs (
2298
+ DC.getKernelDecl (), NameToEmitInDescription,
2299
+ isWrappedField ? " Compiler generated" : KernelArgType.getAsString (),
2300
+ KernelInvocationLoc, KernelArgSize, getKernelArgDesc (KernelArgDesc),
2301
+ (KernelArgDesc == KernelArgDescription::DecomposedMember)
2302
+ ? (" Field:" + KernelArg->getName ().str () + " , " )
2303
+ : " " );
2304
+ }
2305
+
2306
+ void addParam (const FieldDecl *FD, QualType FieldTy) {
2307
+ KernelArgDescription Desc = KernelArgDescription::None;
2308
+ const RecordDecl *RD = FD->getParent ();
2309
+ if (RD && RD->hasAttr <SYCLRequiresDecompositionAttr>())
2310
+ Desc = KernelArgDescription::DecomposedMember;
2311
+
2312
+ addParam (FD, FieldTy, Desc);
2313
+ }
2314
+
2315
+ // Handles base classes.
2316
+ void addParam (const CXXBaseSpecifier &, QualType KernelArgType,
2317
+ KernelArgDescription KernelArgDesc) {
2318
+ unsigned KernelArgSize =
2319
+ SemaRef.getASTContext ().getTypeSizeInChars (KernelArgType).getQuantity ();
2320
+ SemaRef.getDiagnostics ().getSYCLOptReportHandler ().AddKernelArgs (
2321
+ DC.getKernelDecl (), KernelArgType.getAsString (),
2322
+ KernelArgType.getAsString (), KernelInvocationLoc, KernelArgSize,
2323
+ getKernelArgDesc (KernelArgDesc), " " );
2324
+ }
2325
+
2326
+ // Handles specialization constants.
2327
+ void addParam (QualType KernelArgType, KernelArgDescription KernelArgDesc) {
2328
+ unsigned KernelArgSize =
2329
+ SemaRef.getASTContext ().getTypeSizeInChars (KernelArgType).getQuantity ();
2330
+ SemaRef.getDiagnostics ().getSYCLOptReportHandler ().AddKernelArgs (
2331
+ DC.getKernelDecl (), " " , KernelArgType.getAsString (),
2332
+ KernelInvocationLoc, KernelArgSize, getKernelArgDesc (KernelArgDesc),
2333
+ " " );
2334
+ }
2335
+
2336
+ // Handles SYCL special types (accessor, sampler and stream) and modified
2337
+ // types (arrays and pointers)
2338
+ bool handleSpecialType (const FieldDecl *FD, QualType FieldTy,
2339
+ KernelArgDescription Desc) {
2340
+ for (const auto *Param : DC.getParamVarDeclsForCurrentField ())
2341
+ addParam (FD, Param->getType (), Desc);
2342
+ return true ;
2343
+ }
2344
+
2345
+ public:
2346
+ static constexpr const bool VisitInsideSimpleContainers = false ;
2347
+ SyclOptReportCreator (Sema &S, SyclKernelDeclCreator &DC, SourceLocation Loc)
2348
+ : SyclKernelFieldHandler(S), DC(DC), KernelInvocationLoc(Loc) {}
2349
+
2350
+ bool handleSyclAccessorType (FieldDecl *FD, QualType FieldTy) final {
2351
+ return handleSpecialType (
2352
+ FD, FieldTy, KernelArgDescription (KernelArgDescription::Accessor));
2353
+ }
2354
+
2355
+ bool handleSyclAccessorType (const CXXRecordDecl *, const CXXBaseSpecifier &BS,
2356
+ QualType FieldTy) final {
2357
+ for (const auto *Param : DC.getParamVarDeclsForCurrentField ()) {
2358
+ QualType KernelArgType = Param->getType ();
2359
+ unsigned KernelArgSize = SemaRef.getASTContext ()
2360
+ .getTypeSizeInChars (KernelArgType)
2361
+ .getQuantity ();
2362
+ SemaRef.getDiagnostics ().getSYCLOptReportHandler ().AddKernelArgs (
2363
+ DC.getKernelDecl (), FieldTy.getAsString (),
2364
+ KernelArgType.getAsString (), KernelInvocationLoc, KernelArgSize,
2365
+ getKernelArgDesc (
2366
+ KernelArgDescription (KernelArgDescription::AccessorBase)),
2367
+ " " );
2368
+ }
2369
+ return true ;
2370
+ }
2371
+
2372
+ bool handleSyclSamplerType (FieldDecl *FD, QualType FieldTy) final {
2373
+ return handleSpecialType (
2374
+ FD, FieldTy, KernelArgDescription (KernelArgDescription::Sampler));
2375
+ }
2376
+
2377
+ bool handlePointerType (FieldDecl *FD, QualType FieldTy) final {
2378
+ KernelArgDescription Desc = KernelArgDescription::None;
2379
+ ParmVarDecl *KernelParameter = DC.getParamVarDeclsForCurrentField ()[0 ];
2380
+ // Compiler generated openCL kernel argument for current pointer field
2381
+ // is not a pointer. This means we are processing a nested pointer and
2382
+ // the openCL kernel argument is of type __wrapper_class.
2383
+ if (!KernelParameter->getType ()->isPointerType ())
2384
+ Desc = KernelArgDescription::WrappedPointer;
2385
+ return handleSpecialType (FD, FieldTy, Desc);
2386
+ }
2387
+
2388
+ bool handleScalarType (FieldDecl *FD, QualType FieldTy) final {
2389
+ addParam (FD, FieldTy);
2390
+ return true ;
2391
+ }
2392
+
2393
+ bool handleSimpleArrayType (FieldDecl *FD, QualType FieldTy) final {
2394
+ // Simple arrays are always wrapped.
2395
+ handleSpecialType (FD, FieldTy,
2396
+ KernelArgDescription (KernelArgDescription::WrappedArray));
2397
+ return true ;
2398
+ }
2399
+
2400
+ bool handleNonDecompStruct (const CXXRecordDecl *, FieldDecl *FD,
2401
+ QualType Ty) final {
2402
+ addParam (FD, Ty);
2403
+ return true ;
2404
+ }
2405
+
2406
+ bool handleNonDecompStruct (const CXXRecordDecl *Base,
2407
+ const CXXBaseSpecifier &BS, QualType Ty) final {
2408
+ addParam (BS, Ty, KernelArgDescription (KernelArgDescription::BaseClass));
2409
+ return true ;
2410
+ }
2411
+
2412
+ bool handleUnionType (FieldDecl *FD, QualType FieldTy) final {
2413
+ return handleScalarType (FD, FieldTy);
2414
+ }
2415
+
2416
+ bool handleSyclHalfType (FieldDecl *FD, QualType FieldTy) final {
2417
+ addParam (FD, FieldTy);
2418
+ return true ;
2419
+ }
2420
+
2421
+ bool handleSyclStreamType (FieldDecl *FD, QualType FieldTy) final {
2422
+ // For the current implementation of stream class, the Visitor 'handles'
2423
+ // stream argument and then visits each accessor field in stream. Therefore
2424
+ // handleSpecialType in this case only adds a single argument for stream.
2425
+ // The arguments corresponding to accessors in stream are handled in
2426
+ // handleSyclAccessorType. The opt-report therefore does not diffrentiate
2427
+ // between the accessors in streams and accessors captured by SYCL kernel.
2428
+ // Once stream API is modified to use __init(), the visitor will no longer
2429
+ // visit the stream object and opt-report output for stream class will be
2430
+ // similar to that of other special types.
2431
+ return handleSpecialType (
2432
+ FD, FieldTy, KernelArgDescription (KernelArgDescription::Stream));
2433
+ }
2434
+
2435
+ void handleSyclKernelHandlerType () {
2436
+ ASTContext &Context = SemaRef.getASTContext ();
2437
+ if (isDefaultSPIRArch (Context))
2438
+ return ;
2439
+ addParam (DC.getParamVarDeclsForCurrentField ()[0 ]->getType (),
2440
+ KernelArgDescription (KernelArgDescription::KernelHandler));
2441
+ }
2442
+ using SyclKernelFieldHandler::handleSyclHalfType;
2443
+ using SyclKernelFieldHandler::handleSyclSamplerType;
2444
+ using SyclKernelFieldHandler::handleSyclStreamType;
2445
+ };
2446
+
2242
2447
static CXXMethodDecl *getOperatorParens (const CXXRecordDecl *Rec) {
2243
2448
for (auto *MD : Rec->methods ()) {
2244
2449
if (MD->getOverloadedOperator () == OO_Call)
@@ -3561,18 +3766,20 @@ void Sema::ConstructOpenCLKernel(FunctionDecl *KernelCallerFunc,
3561
3766
StableName, KernelCallerFunc);
3562
3767
3563
3768
SyclKernelIntFooterCreator int_footer (*this , getSyclIntegrationFooter ());
3769
+ SyclOptReportCreator opt_report (*this , kernel_decl, KernelObj->getLocation ());
3564
3770
3565
3771
KernelObjVisitor Visitor{*this };
3566
3772
Visitor.VisitRecordBases (KernelObj, kernel_decl, kernel_body, int_header,
3567
- int_footer);
3773
+ int_footer, opt_report );
3568
3774
Visitor.VisitRecordFields (KernelObj, kernel_decl, kernel_body, int_header,
3569
- int_footer);
3775
+ int_footer, opt_report );
3570
3776
3571
3777
if (ParmVarDecl *KernelHandlerArg =
3572
3778
getSyclKernelHandlerArg (KernelCallerFunc)) {
3573
3779
kernel_decl.handleSyclKernelHandlerType ();
3574
3780
kernel_body.handleSyclKernelHandlerType (KernelHandlerArg);
3575
3781
int_header.handleSyclKernelHandlerType (KernelHandlerArg->getType ());
3782
+ opt_report.handleSyclKernelHandlerType ();
3576
3783
}
3577
3784
}
3578
3785
0 commit comments