clang/lib/Sema/SemaSYCL.cpp

   1 //===- SemaSYCL.cpp - Semantic Analysis for SYCL constructs ---------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 // This implements Semantic Analysis for SYCL constructs.
   9 //===----------------------------------------------------------------------===//
  10
  11 #include "clang/AST/Mangle.h"
  12 #include "clang/Sema/Sema.h"
  13 #include "clang/Sema/SemaDiagnostic.h"
  14
  15 using namespace clang;
  16
  17 // -----------------------------------------------------------------------------
  18 // SYCL device specific diagnostics implementation
  19 // -----------------------------------------------------------------------------
  20
  21 Sema::SemaDiagnosticBuilder Sema::SYCLDiagIfDeviceCode(SourceLocation Loc,
  22                                                        unsigned DiagID) {
  23   assert(getLangOpts().SYCLIsDevice &&
  24          "Should only be called during SYCL compilation");
  25   FunctionDecl *FD = dyn_cast<FunctionDecl>(getCurLexicalContext());
  26   SemaDiagnosticBuilder::Kind DiagKind = [this, FD] {
  27     if (!FD)
  28       return SemaDiagnosticBuilder::K_Nop;
  29     if (getEmissionStatus(FD) == Sema::FunctionEmissionStatus::Emitted)
  30       return SemaDiagnosticBuilder::K_ImmediateWithCallStack;
  31     return SemaDiagnosticBuilder::K_Deferred;
  32   }();
  33   return SemaDiagnosticBuilder(DiagKind, Loc, DiagID, FD, *this);
  34 }
  35
  36 bool Sema::checkSYCLDeviceFunction(SourceLocation Loc, FunctionDecl *Callee) {
  37   assert(getLangOpts().SYCLIsDevice &&
  38          "Should only be called during SYCL compilation");
  39   assert(Callee && "Callee may not be null.");
  40
  41   // Errors in an unevaluated context don't need to be generated,
  42   // so we can safely skip them.
  43   if (isUnevaluatedContext() || isConstantEvaluated())
  44     return true;
  45
  46   SemaDiagnosticBuilder::Kind DiagKind = SemaDiagnosticBuilder::K_Nop;
  47
  48   return DiagKind != SemaDiagnosticBuilder::K_Immediate &&
  49          DiagKind != SemaDiagnosticBuilder::K_ImmediateWithCallStack;
  50 }
  51
  52 static bool isZeroSizedArray(Sema &SemaRef, QualType Ty) {
  53   if (const auto *CAT = SemaRef.getASTContext().getAsConstantArrayType(Ty))
  54     return CAT->getSize() == 0;
  55   return false;
  56 }
  57
  58 void Sema::deepTypeCheckForSYCLDevice(SourceLocation UsedAt,
  59                                       llvm::DenseSet<QualType> Visited,
  60                                       ValueDecl *DeclToCheck) {
  61   assert(getLangOpts().SYCLIsDevice &&
  62          "Should only be called during SYCL compilation");
  63   // Emit notes only for the first discovered declaration of unsupported type
  64   // to avoid mess of notes. This flag is to track that error already happened.
  65   bool NeedToEmitNotes = true;
  66
  67   auto Check = [&](QualType TypeToCheck, const ValueDecl *D) {
  68     bool ErrorFound = false;
  69     if (isZeroSizedArray(*this, TypeToCheck)) {
  70       SYCLDiagIfDeviceCode(UsedAt, diag::err_typecheck_zero_array_size) << 1;
  71       ErrorFound = true;
  72     }
  73     // Checks for other types can also be done here.
  74     if (ErrorFound) {
  75       if (NeedToEmitNotes) {
  76         if (auto *FD = dyn_cast<FieldDecl>(D))
  77           SYCLDiagIfDeviceCode(FD->getLocation(),
  78                                diag::note_illegal_field_declared_here)
  79               << FD->getType()->isPointerType() << FD->getType();
  80         else
  81           SYCLDiagIfDeviceCode(D->getLocation(), diag::note_declared_at);
  82       }
  83     }
  84
  85     return ErrorFound;
  86   };
  87
  88   // In case we have a Record used do the DFS for a bad field.
  89   SmallVector<const ValueDecl *, 4> StackForRecursion;
  90   StackForRecursion.push_back(DeclToCheck);
  91
  92   // While doing DFS save how we get there to emit a nice set of notes.
  93   SmallVector<const FieldDecl *, 4> History;
  94   History.push_back(nullptr);
  95
  96   do {
  97     const ValueDecl *Next = StackForRecursion.pop_back_val();
  98     if (!Next) {
  99       assert(!History.empty());
 100       // Found a marker, we have gone up a level.
 101       History.pop_back();
 102       continue;
 103     }
 104     QualType NextTy = Next->getType();
 105
 106     if (!Visited.insert(NextTy).second)
 107       continue;
 108
 109     auto EmitHistory = [&]() {
 110       // The first element is always nullptr.
 111       for (uint64_t Index = 1; Index < History.size(); ++Index) {
 112         SYCLDiagIfDeviceCode(History[Index]->getLocation(),
 113                              diag::note_within_field_of_type)
 114             << History[Index]->getType();
 115       }
 116     };
 117
 118     if (Check(NextTy, Next)) {
 119       if (NeedToEmitNotes)
 120         EmitHistory();
 121       NeedToEmitNotes = false;
 122     }
 123
 124     // In case pointer/array/reference type is met get pointee type, then
 125     // proceed with that type.
 126     while (NextTy->isAnyPointerType() || NextTy->isArrayType() ||
 127            NextTy->isReferenceType()) {
 128       if (NextTy->isArrayType())
 129         NextTy = QualType{NextTy->getArrayElementTypeNoTypeQual(), 0};
 130       else
 131         NextTy = NextTy->getPointeeType();
 132       if (Check(NextTy, Next)) {
 133         if (NeedToEmitNotes)
 134           EmitHistory();
 135         NeedToEmitNotes = false;
 136       }
 137     }
 138
 139     if (const auto *RecDecl = NextTy->getAsRecordDecl()) {
 140       if (auto *NextFD = dyn_cast<FieldDecl>(Next))
 141         History.push_back(NextFD);
 142       // When nullptr is discovered, this means we've gone back up a level, so
 143       // the history should be cleaned.
 144       StackForRecursion.push_back(nullptr);
 145       llvm::copy(RecDecl->fields(), std::back_inserter(StackForRecursion));
 146     }
 147   } while (!StackForRecursion.empty());
 148 }