clang  7.0.0svn
SemaCUDA.cpp
Go to the documentation of this file.
1 //===--- SemaCUDA.cpp - Semantic Analysis for CUDA constructs -------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 /// \file
10 /// This file implements semantic analysis for CUDA constructs.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/Decl.h"
16 #include "clang/AST/ExprCXX.h"
17 #include "clang/Lex/Preprocessor.h"
18 #include "clang/Sema/Lookup.h"
19 #include "clang/Sema/Sema.h"
22 #include "clang/Sema/Template.h"
23 #include "llvm/ADT/Optional.h"
24 #include "llvm/ADT/SmallVector.h"
25 using namespace clang;
26 
28  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
29  ForceCUDAHostDeviceDepth++;
30 }
31 
33  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
34  if (ForceCUDAHostDeviceDepth == 0)
35  return false;
36  ForceCUDAHostDeviceDepth--;
37  return true;
38 }
39 
41  MultiExprArg ExecConfig,
42  SourceLocation GGGLoc) {
44  if (!ConfigDecl)
45  return ExprError(
46  Diag(LLLLoc, diag::err_undeclared_var_use)
47  << (getLangOpts().HIP ? "hipConfigureCall" : "cudaConfigureCall"));
48  QualType ConfigQTy = ConfigDecl->getType();
49 
50  DeclRefExpr *ConfigDR = new (Context)
51  DeclRefExpr(ConfigDecl, false, ConfigQTy, VK_LValue, LLLLoc);
52  MarkFunctionReferenced(LLLLoc, ConfigDecl);
53 
54  return ActOnCallExpr(S, ConfigDR, LLLLoc, ExecConfig, GGGLoc, nullptr,
55  /*IsExecConfig=*/true);
56 }
57 
59  bool HasHostAttr = false;
60  bool HasDeviceAttr = false;
61  bool HasGlobalAttr = false;
62  bool HasInvalidTargetAttr = false;
63  while (Attr) {
64  switch(Attr->getKind()){
65  case AttributeList::AT_CUDAGlobal:
66  HasGlobalAttr = true;
67  break;
68  case AttributeList::AT_CUDAHost:
69  HasHostAttr = true;
70  break;
71  case AttributeList::AT_CUDADevice:
72  HasDeviceAttr = true;
73  break;
74  case AttributeList::AT_CUDAInvalidTarget:
75  HasInvalidTargetAttr = true;
76  break;
77  default:
78  break;
79  }
80  Attr = Attr->getNext();
81  }
82  if (HasInvalidTargetAttr)
83  return CFT_InvalidTarget;
84 
85  if (HasGlobalAttr)
86  return CFT_Global;
87 
88  if (HasHostAttr && HasDeviceAttr)
89  return CFT_HostDevice;
90 
91  if (HasDeviceAttr)
92  return CFT_Device;
93 
94  return CFT_Host;
95 }
96 
97 template <typename A>
98 static bool hasAttr(const FunctionDecl *D, bool IgnoreImplicitAttr) {
99  return D->hasAttrs() && llvm::any_of(D->getAttrs(), [&](Attr *Attribute) {
100  return isa<A>(Attribute) &&
101  !(IgnoreImplicitAttr && Attribute->isImplicit());
102  });
103 }
104 
105 /// IdentifyCUDATarget - Determine the CUDA compilation target for this function
107  bool IgnoreImplicitHDAttr) {
108  // Code that lives outside a function is run on the host.
109  if (D == nullptr)
110  return CFT_Host;
111 
112  if (D->hasAttr<CUDAInvalidTargetAttr>())
113  return CFT_InvalidTarget;
114 
115  if (D->hasAttr<CUDAGlobalAttr>())
116  return CFT_Global;
117 
118  if (hasAttr<CUDADeviceAttr>(D, IgnoreImplicitHDAttr)) {
119  if (hasAttr<CUDAHostAttr>(D, IgnoreImplicitHDAttr))
120  return CFT_HostDevice;
121  return CFT_Device;
122  } else if (hasAttr<CUDAHostAttr>(D, IgnoreImplicitHDAttr)) {
123  return CFT_Host;
124  } else if (D->isImplicit() && !IgnoreImplicitHDAttr) {
125  // Some implicit declarations (like intrinsic functions) are not marked.
126  // Set the most lenient target on them for maximal flexibility.
127  return CFT_HostDevice;
128  }
129 
130  return CFT_Host;
131 }
132 
133 // * CUDA Call preference table
134 //
135 // F - from,
136 // T - to
137 // Ph - preference in host mode
138 // Pd - preference in device mode
139 // H - handled in (x)
140 // Preferences: N:native, SS:same side, HD:host-device, WS:wrong side, --:never.
141 //
142 // | F | T | Ph | Pd | H |
143 // |----+----+-----+-----+-----+
144 // | d | d | N | N | (c) |
145 // | d | g | -- | -- | (a) |
146 // | d | h | -- | -- | (e) |
147 // | d | hd | HD | HD | (b) |
148 // | g | d | N | N | (c) |
149 // | g | g | -- | -- | (a) |
150 // | g | h | -- | -- | (e) |
151 // | g | hd | HD | HD | (b) |
152 // | h | d | -- | -- | (e) |
153 // | h | g | N | N | (c) |
154 // | h | h | N | N | (c) |
155 // | h | hd | HD | HD | (b) |
156 // | hd | d | WS | SS | (d) |
157 // | hd | g | SS | -- |(d/a)|
158 // | hd | h | SS | WS | (d) |
159 // | hd | hd | HD | HD | (b) |
160 
163  const FunctionDecl *Callee) {
164  assert(Callee && "Callee must be valid.");
165  CUDAFunctionTarget CallerTarget = IdentifyCUDATarget(Caller);
166  CUDAFunctionTarget CalleeTarget = IdentifyCUDATarget(Callee);
167 
168  // If one of the targets is invalid, the check always fails, no matter what
169  // the other target is.
170  if (CallerTarget == CFT_InvalidTarget || CalleeTarget == CFT_InvalidTarget)
171  return CFP_Never;
172 
173  // (a) Can't call global from some contexts until we support CUDA's
174  // dynamic parallelism.
175  if (CalleeTarget == CFT_Global &&
176  (CallerTarget == CFT_Global || CallerTarget == CFT_Device))
177  return CFP_Never;
178 
179  // (b) Calling HostDevice is OK for everyone.
180  if (CalleeTarget == CFT_HostDevice)
181  return CFP_HostDevice;
182 
183  // (c) Best case scenarios
184  if (CalleeTarget == CallerTarget ||
185  (CallerTarget == CFT_Host && CalleeTarget == CFT_Global) ||
186  (CallerTarget == CFT_Global && CalleeTarget == CFT_Device))
187  return CFP_Native;
188 
189  // (d) HostDevice behavior depends on compilation mode.
190  if (CallerTarget == CFT_HostDevice) {
191  // It's OK to call a compilation-mode matching function from an HD one.
192  if ((getLangOpts().CUDAIsDevice && CalleeTarget == CFT_Device) ||
193  (!getLangOpts().CUDAIsDevice &&
194  (CalleeTarget == CFT_Host || CalleeTarget == CFT_Global)))
195  return CFP_SameSide;
196 
197  // Calls from HD to non-mode-matching functions (i.e., to host functions
198  // when compiling in device mode or to device functions when compiling in
199  // host mode) are allowed at the sema level, but eventually rejected if
200  // they're ever codegened. TODO: Reject said calls earlier.
201  return CFP_WrongSide;
202  }
203 
204  // (e) Calling across device/host boundary is not something you should do.
205  if ((CallerTarget == CFT_Host && CalleeTarget == CFT_Device) ||
206  (CallerTarget == CFT_Device && CalleeTarget == CFT_Host) ||
207  (CallerTarget == CFT_Global && CalleeTarget == CFT_Host))
208  return CFP_Never;
209 
210  llvm_unreachable("All cases should've been handled by now.");
211 }
212 
214  const FunctionDecl *Caller,
215  SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches) {
216  if (Matches.size() <= 1)
217  return;
218 
219  using Pair = std::pair<DeclAccessPair, FunctionDecl*>;
220 
221  // Gets the CUDA function preference for a call from Caller to Match.
222  auto GetCFP = [&](const Pair &Match) {
223  return IdentifyCUDAPreference(Caller, Match.second);
224  };
225 
226  // Find the best call preference among the functions in Matches.
227  CUDAFunctionPreference BestCFP = GetCFP(*std::max_element(
228  Matches.begin(), Matches.end(),
229  [&](const Pair &M1, const Pair &M2) { return GetCFP(M1) < GetCFP(M2); }));
230 
231  // Erase all functions with lower priority.
232  llvm::erase_if(Matches,
233  [&](const Pair &Match) { return GetCFP(Match) < BestCFP; });
234 }
235 
236 /// When an implicitly-declared special member has to invoke more than one
237 /// base/field special member, conflicts may occur in the targets of these
238 /// members. For example, if one base's member __host__ and another's is
239 /// __device__, it's a conflict.
240 /// This function figures out if the given targets \param Target1 and
241 /// \param Target2 conflict, and if they do not it fills in
242 /// \param ResolvedTarget with a target that resolves for both calls.
243 /// \return true if there's a conflict, false otherwise.
244 static bool
246  Sema::CUDAFunctionTarget Target2,
247  Sema::CUDAFunctionTarget *ResolvedTarget) {
248  // Only free functions and static member functions may be global.
249  assert(Target1 != Sema::CFT_Global);
250  assert(Target2 != Sema::CFT_Global);
251 
252  if (Target1 == Sema::CFT_HostDevice) {
253  *ResolvedTarget = Target2;
254  } else if (Target2 == Sema::CFT_HostDevice) {
255  *ResolvedTarget = Target1;
256  } else if (Target1 != Target2) {
257  return true;
258  } else {
259  *ResolvedTarget = Target1;
260  }
261 
262  return false;
263 }
264 
266  CXXSpecialMember CSM,
267  CXXMethodDecl *MemberDecl,
268  bool ConstRHS,
269  bool Diagnose) {
270  llvm::Optional<CUDAFunctionTarget> InferredTarget;
271 
272  // We're going to invoke special member lookup; mark that these special
273  // members are called from this one, and not from its caller.
274  ContextRAII MethodContext(*this, MemberDecl);
275 
276  // Look for special members in base classes that should be invoked from here.
277  // Infer the target of this member base on the ones it should call.
278  // Skip direct and indirect virtual bases for abstract classes.
280  for (const auto &B : ClassDecl->bases()) {
281  if (!B.isVirtual()) {
282  Bases.push_back(&B);
283  }
284  }
285 
286  if (!ClassDecl->isAbstract()) {
287  for (const auto &VB : ClassDecl->vbases()) {
288  Bases.push_back(&VB);
289  }
290  }
291 
292  for (const auto *B : Bases) {
293  const RecordType *BaseType = B->getType()->getAs<RecordType>();
294  if (!BaseType) {
295  continue;
296  }
297 
298  CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
300  LookupSpecialMember(BaseClassDecl, CSM,
301  /* ConstArg */ ConstRHS,
302  /* VolatileArg */ false,
303  /* RValueThis */ false,
304  /* ConstThis */ false,
305  /* VolatileThis */ false);
306 
307  if (!SMOR.getMethod())
308  continue;
309 
310  CUDAFunctionTarget BaseMethodTarget = IdentifyCUDATarget(SMOR.getMethod());
311  if (!InferredTarget.hasValue()) {
312  InferredTarget = BaseMethodTarget;
313  } else {
314  bool ResolutionError = resolveCalleeCUDATargetConflict(
315  InferredTarget.getValue(), BaseMethodTarget,
316  InferredTarget.getPointer());
317  if (ResolutionError) {
318  if (Diagnose) {
319  Diag(ClassDecl->getLocation(),
320  diag::note_implicit_member_target_infer_collision)
321  << (unsigned)CSM << InferredTarget.getValue() << BaseMethodTarget;
322  }
323  MemberDecl->addAttr(CUDAInvalidTargetAttr::CreateImplicit(Context));
324  return true;
325  }
326  }
327  }
328 
329  // Same as for bases, but now for special members of fields.
330  for (const auto *F : ClassDecl->fields()) {
331  if (F->isInvalidDecl()) {
332  continue;
333  }
334 
335  const RecordType *FieldType =
336  Context.getBaseElementType(F->getType())->getAs<RecordType>();
337  if (!FieldType) {
338  continue;
339  }
340 
341  CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(FieldType->getDecl());
343  LookupSpecialMember(FieldRecDecl, CSM,
344  /* ConstArg */ ConstRHS && !F->isMutable(),
345  /* VolatileArg */ false,
346  /* RValueThis */ false,
347  /* ConstThis */ false,
348  /* VolatileThis */ false);
349 
350  if (!SMOR.getMethod())
351  continue;
352 
353  CUDAFunctionTarget FieldMethodTarget =
354  IdentifyCUDATarget(SMOR.getMethod());
355  if (!InferredTarget.hasValue()) {
356  InferredTarget = FieldMethodTarget;
357  } else {
358  bool ResolutionError = resolveCalleeCUDATargetConflict(
359  InferredTarget.getValue(), FieldMethodTarget,
360  InferredTarget.getPointer());
361  if (ResolutionError) {
362  if (Diagnose) {
363  Diag(ClassDecl->getLocation(),
364  diag::note_implicit_member_target_infer_collision)
365  << (unsigned)CSM << InferredTarget.getValue()
366  << FieldMethodTarget;
367  }
368  MemberDecl->addAttr(CUDAInvalidTargetAttr::CreateImplicit(Context));
369  return true;
370  }
371  }
372  }
373 
374  if (InferredTarget.hasValue()) {
375  if (InferredTarget.getValue() == CFT_Device) {
376  MemberDecl->addAttr(CUDADeviceAttr::CreateImplicit(Context));
377  } else if (InferredTarget.getValue() == CFT_Host) {
378  MemberDecl->addAttr(CUDAHostAttr::CreateImplicit(Context));
379  } else {
380  MemberDecl->addAttr(CUDADeviceAttr::CreateImplicit(Context));
381  MemberDecl->addAttr(CUDAHostAttr::CreateImplicit(Context));
382  }
383  } else {
384  // If no target was inferred, mark this member as __host__ __device__;
385  // it's the least restrictive option that can be invoked from any target.
386  MemberDecl->addAttr(CUDADeviceAttr::CreateImplicit(Context));
387  MemberDecl->addAttr(CUDAHostAttr::CreateImplicit(Context));
388  }
389 
390  return false;
391 }
392 
394  if (!CD->isDefined() && CD->isTemplateInstantiation())
396 
397  // (E.2.3.1, CUDA 7.5) A constructor for a class type is considered
398  // empty at a point in the translation unit, if it is either a
399  // trivial constructor
400  if (CD->isTrivial())
401  return true;
402 
403  // ... or it satisfies all of the following conditions:
404  // The constructor function has been defined.
405  // The constructor function has no parameters,
406  // and the function body is an empty compound statement.
407  if (!(CD->hasTrivialBody() && CD->getNumParams() == 0))
408  return false;
409 
410  // Its class has no virtual functions and no virtual base classes.
411  if (CD->getParent()->isDynamicClass())
412  return false;
413 
414  // The only form of initializer allowed is an empty constructor.
415  // This will recursively check all base classes and member initializers
416  if (!llvm::all_of(CD->inits(), [&](const CXXCtorInitializer *CI) {
417  if (const CXXConstructExpr *CE =
418  dyn_cast<CXXConstructExpr>(CI->getInit()))
419  return isEmptyCudaConstructor(Loc, CE->getConstructor());
420  return false;
421  }))
422  return false;
423 
424  return true;
425 }
426 
428  // No destructor -> no problem.
429  if (!DD)
430  return true;
431 
432  if (!DD->isDefined() && DD->isTemplateInstantiation())
434 
435  // (E.2.3.1, CUDA 7.5) A destructor for a class type is considered
436  // empty at a point in the translation unit, if it is either a
437  // trivial constructor
438  if (DD->isTrivial())
439  return true;
440 
441  // ... or it satisfies all of the following conditions:
442  // The destructor function has been defined.
443  // and the function body is an empty compound statement.
444  if (!DD->hasTrivialBody())
445  return false;
446 
447  const CXXRecordDecl *ClassDecl = DD->getParent();
448 
449  // Its class has no virtual functions and no virtual base classes.
450  if (ClassDecl->isDynamicClass())
451  return false;
452 
453  // Only empty destructors are allowed. This will recursively check
454  // destructors for all base classes...
455  if (!llvm::all_of(ClassDecl->bases(), [&](const CXXBaseSpecifier &BS) {
456  if (CXXRecordDecl *RD = BS.getType()->getAsCXXRecordDecl())
457  return isEmptyCudaDestructor(Loc, RD->getDestructor());
458  return true;
459  }))
460  return false;
461 
462  // ... and member fields.
463  if (!llvm::all_of(ClassDecl->fields(), [&](const FieldDecl *Field) {
464  if (CXXRecordDecl *RD = Field->getType()
465  ->getBaseElementTypeUnsafe()
466  ->getAsCXXRecordDecl())
467  return isEmptyCudaDestructor(Loc, RD->getDestructor());
468  return true;
469  }))
470  return false;
471 
472  return true;
473 }
474 
476  if (VD->isInvalidDecl() || !VD->hasInit() || !VD->hasGlobalStorage())
477  return;
478  const Expr *Init = VD->getInit();
479  if (VD->hasAttr<CUDADeviceAttr>() || VD->hasAttr<CUDAConstantAttr>() ||
480  VD->hasAttr<CUDASharedAttr>()) {
481  assert(!VD->isStaticLocal() || VD->hasAttr<CUDASharedAttr>());
482  bool AllowedInit = false;
483  if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(Init))
484  AllowedInit =
485  isEmptyCudaConstructor(VD->getLocation(), CE->getConstructor());
486  // We'll allow constant initializers even if it's a non-empty
487  // constructor according to CUDA rules. This deviates from NVCC,
488  // but allows us to handle things like constexpr constructors.
489  if (!AllowedInit &&
490  (VD->hasAttr<CUDADeviceAttr>() || VD->hasAttr<CUDAConstantAttr>()))
491  AllowedInit = VD->getInit()->isConstantInitializer(
492  Context, VD->getType()->isReferenceType());
493 
494  // Also make sure that destructor, if there is one, is empty.
495  if (AllowedInit)
496  if (CXXRecordDecl *RD = VD->getType()->getAsCXXRecordDecl())
497  AllowedInit =
498  isEmptyCudaDestructor(VD->getLocation(), RD->getDestructor());
499 
500  if (!AllowedInit) {
501  Diag(VD->getLocation(), VD->hasAttr<CUDASharedAttr>()
502  ? diag::err_shared_var_init
503  : diag::err_dynamic_var_init)
504  << Init->getSourceRange();
505  VD->setInvalidDecl();
506  }
507  } else {
508  // This is a host-side global variable. Check that the initializer is
509  // callable from the host side.
510  const FunctionDecl *InitFn = nullptr;
511  if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(Init)) {
512  InitFn = CE->getConstructor();
513  } else if (const CallExpr *CE = dyn_cast<CallExpr>(Init)) {
514  InitFn = CE->getDirectCallee();
515  }
516  if (InitFn) {
517  CUDAFunctionTarget InitFnTarget = IdentifyCUDATarget(InitFn);
518  if (InitFnTarget != CFT_Host && InitFnTarget != CFT_HostDevice) {
519  Diag(VD->getLocation(), diag::err_ref_bad_target_global_initializer)
520  << InitFnTarget << InitFn;
521  Diag(InitFn->getLocation(), diag::note_previous_decl) << InitFn;
522  VD->setInvalidDecl();
523  }
524  }
525  }
526 }
527 
528 // With -fcuda-host-device-constexpr, an unattributed constexpr function is
529 // treated as implicitly __host__ __device__, unless:
530 // * it is a variadic function (device-side variadic functions are not
531 // allowed), or
532 // * a __device__ function with this signature was already declared, in which
533 // case in which case we output an error, unless the __device__ decl is in a
534 // system header, in which case we leave the constexpr function unattributed.
535 //
536 // In addition, all function decls are treated as __host__ __device__ when
537 // ForceCUDAHostDeviceDepth > 0 (corresponding to code within a
538 // #pragma clang force_cuda_host_device_begin/end
539 // pair).
541  const LookupResult &Previous) {
542  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
543 
544  if (ForceCUDAHostDeviceDepth > 0) {
545  if (!NewD->hasAttr<CUDAHostAttr>())
546  NewD->addAttr(CUDAHostAttr::CreateImplicit(Context));
547  if (!NewD->hasAttr<CUDADeviceAttr>())
548  NewD->addAttr(CUDADeviceAttr::CreateImplicit(Context));
549  return;
550  }
551 
552  if (!getLangOpts().CUDAHostDeviceConstexpr || !NewD->isConstexpr() ||
553  NewD->isVariadic() || NewD->hasAttr<CUDAHostAttr>() ||
554  NewD->hasAttr<CUDADeviceAttr>() || NewD->hasAttr<CUDAGlobalAttr>())
555  return;
556 
557  // Is D a __device__ function with the same signature as NewD, ignoring CUDA
558  // attributes?
559  auto IsMatchingDeviceFn = [&](NamedDecl *D) {
560  if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(D))
561  D = Using->getTargetDecl();
562  FunctionDecl *OldD = D->getAsFunction();
563  return OldD && OldD->hasAttr<CUDADeviceAttr>() &&
564  !OldD->hasAttr<CUDAHostAttr>() &&
565  !IsOverload(NewD, OldD, /* UseMemberUsingDeclRules = */ false,
566  /* ConsiderCudaAttrs = */ false);
567  };
568  auto It = llvm::find_if(Previous, IsMatchingDeviceFn);
569  if (It != Previous.end()) {
570  // We found a __device__ function with the same name and signature as NewD
571  // (ignoring CUDA attrs). This is an error unless that function is defined
572  // in a system header, in which case we simply return without making NewD
573  // host+device.
574  NamedDecl *Match = *It;
575  if (!getSourceManager().isInSystemHeader(Match->getLocation())) {
576  Diag(NewD->getLocation(),
577  diag::err_cuda_unattributed_constexpr_cannot_overload_device)
578  << NewD;
579  Diag(Match->getLocation(),
580  diag::note_cuda_conflicting_device_function_declared_here);
581  }
582  return;
583  }
584 
585  NewD->addAttr(CUDAHostAttr::CreateImplicit(Context));
586  NewD->addAttr(CUDADeviceAttr::CreateImplicit(Context));
587 }
588 
589 // In CUDA, there are some constructs which may appear in semantically-valid
590 // code, but trigger errors if we ever generate code for the function in which
591 // they appear. Essentially every construct you're not allowed to use on the
592 // device falls into this category, because you are allowed to use these
593 // constructs in a __host__ __device__ function, but only if that function is
594 // never codegen'ed on the device.
595 //
596 // To handle semantic checking for these constructs, we keep track of the set of
597 // functions we know will be emitted, either because we could tell a priori that
598 // they would be emitted, or because they were transitively called by a
599 // known-emitted function.
600 //
601 // We also keep a partial call graph of which not-known-emitted functions call
602 // which other not-known-emitted functions.
603 //
604 // When we see something which is illegal if the current function is emitted
605 // (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
606 // CheckCUDACall), we first check if the current function is known-emitted. If
607 // so, we immediately output the diagnostic.
608 //
609 // Otherwise, we "defer" the diagnostic. It sits in Sema::CUDADeferredDiags
610 // until we discover that the function is known-emitted, at which point we take
611 // it out of this map and emit the diagnostic.
612 
614  unsigned DiagID, FunctionDecl *Fn,
615  Sema &S)
616  : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
617  ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
618  switch (K) {
619  case K_Nop:
620  break;
621  case K_Immediate:
623  ImmediateDiag.emplace(S.Diag(Loc, DiagID));
624  break;
625  case K_Deferred:
626  assert(Fn && "Must have a function to attach the deferred diag to.");
627  PartialDiag.emplace(S.PDiag(DiagID));
628  break;
629  }
630 }
631 
632 // Print notes showing how we can reach FD starting from an a priori
633 // known-callable function.
634 static void EmitCallStackNotes(Sema &S, FunctionDecl *FD) {
635  auto FnIt = S.CUDAKnownEmittedFns.find(FD);
636  while (FnIt != S.CUDAKnownEmittedFns.end()) {
637  DiagnosticBuilder Builder(
638  S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
639  Builder << FnIt->second.FD;
640  Builder.setForceEmit();
641 
642  FnIt = S.CUDAKnownEmittedFns.find(FnIt->second.FD);
643  }
644 }
645 
647  if (ImmediateDiag) {
648  // Emit our diagnostic and, if it was a warning or error, output a callstack
649  // if Fn isn't a priori known-emitted.
650  bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
651  DiagID, Loc) >= DiagnosticsEngine::Warning;
652  ImmediateDiag.reset(); // Emit the immediate diag.
653  if (IsWarningOrError && ShowCallStack)
654  EmitCallStackNotes(S, Fn);
655  } else if (PartialDiag) {
656  assert(ShowCallStack && "Must always show call stack for deferred diags.");
657  S.CUDADeferredDiags[Fn].push_back({Loc, std::move(*PartialDiag)});
658  }
659 }
660 
661 // Do we know that we will eventually codegen the given function?
662 static bool IsKnownEmitted(Sema &S, FunctionDecl *FD) {
663  // Templates are emitted when they're instantiated.
664  if (FD->isDependentContext())
665  return false;
666 
667  // When compiling for device, host functions are never emitted. Similarly,
668  // when compiling for host, device and global functions are never emitted.
669  // (Technically, we do emit a host-side stub for global functions, but this
670  // doesn't count for our purposes here.)
672  if (S.getLangOpts().CUDAIsDevice && T == Sema::CFT_Host)
673  return false;
674  if (!S.getLangOpts().CUDAIsDevice &&
675  (T == Sema::CFT_Device || T == Sema::CFT_Global))
676  return false;
677 
678  // Check whether this function is externally visible -- if so, it's
679  // known-emitted.
680  //
681  // We have to check the GVA linkage of the function's *definition* -- if we
682  // only have a declaration, we don't know whether or not the function will be
683  // emitted, because (say) the definition could include "inline".
684  FunctionDecl *Def = FD->getDefinition();
685 
686  if (Def &&
688  return true;
689 
690  // Otherwise, the function is known-emitted if it's in our set of
691  // known-emitted functions.
692  return S.CUDAKnownEmittedFns.count(FD) > 0;
693 }
694 
696  unsigned DiagID) {
697  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
698  CUDADiagBuilder::Kind DiagKind = [&] {
699  switch (CurrentCUDATarget()) {
700  case CFT_Global:
701  case CFT_Device:
703  case CFT_HostDevice:
704  // An HD function counts as host code if we're compiling for host, and
705  // device code if we're compiling for device. Defer any errors in device
706  // mode until the function is known-emitted.
707  if (getLangOpts().CUDAIsDevice) {
708  return IsKnownEmitted(*this, dyn_cast<FunctionDecl>(CurContext))
711  }
712  return CUDADiagBuilder::K_Nop;
713 
714  default:
715  return CUDADiagBuilder::K_Nop;
716  }
717  }();
718  return CUDADiagBuilder(DiagKind, Loc, DiagID,
719  dyn_cast<FunctionDecl>(CurContext), *this);
720 }
721 
723  unsigned DiagID) {
724  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
725  CUDADiagBuilder::Kind DiagKind = [&] {
726  switch (CurrentCUDATarget()) {
727  case CFT_Host:
729  case CFT_HostDevice:
730  // An HD function counts as host code if we're compiling for host, and
731  // device code if we're compiling for device. Defer any errors in device
732  // mode until the function is known-emitted.
733  if (getLangOpts().CUDAIsDevice)
734  return CUDADiagBuilder::K_Nop;
735 
736  return IsKnownEmitted(*this, dyn_cast<FunctionDecl>(CurContext))
739  default:
740  return CUDADiagBuilder::K_Nop;
741  }
742  }();
743  return CUDADiagBuilder(DiagKind, Loc, DiagID,
744  dyn_cast<FunctionDecl>(CurContext), *this);
745 }
746 
747 // Emit any deferred diagnostics for FD and erase them from the map in which
748 // they're stored.
749 static void EmitDeferredDiags(Sema &S, FunctionDecl *FD) {
750  auto It = S.CUDADeferredDiags.find(FD);
751  if (It == S.CUDADeferredDiags.end())
752  return;
753  bool HasWarningOrError = false;
754  for (PartialDiagnosticAt &PDAt : It->second) {
755  const SourceLocation &Loc = PDAt.first;
756  const PartialDiagnostic &PD = PDAt.second;
757  HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
759  DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
760  Builder.setForceEmit();
761  PD.Emit(Builder);
762  }
763  S.CUDADeferredDiags.erase(It);
764 
765  // FIXME: Should this be called after every warning/error emitted in the loop
766  // above, instead of just once per function? That would be consistent with
767  // how we handle immediate errors, but it also seems like a bit much.
768  if (HasWarningOrError)
769  EmitCallStackNotes(S, FD);
770 }
771 
772 // Indicate that this function (and thus everything it transtively calls) will
773 // be codegen'ed, and emit any deferred diagnostics on this function and its
774 // (transitive) callees.
775 static void MarkKnownEmitted(Sema &S, FunctionDecl *OrigCaller,
776  FunctionDecl *OrigCallee, SourceLocation OrigLoc) {
777  // Nothing to do if we already know that FD is emitted.
778  if (IsKnownEmitted(S, OrigCallee)) {
779  assert(!S.CUDACallGraph.count(OrigCallee));
780  return;
781  }
782 
783  // We've just discovered that OrigCallee is known-emitted. Walk our call
784  // graph to see what else we can now discover also must be emitted.
785 
786  struct CallInfo {
787  FunctionDecl *Caller;
788  FunctionDecl *Callee;
789  SourceLocation Loc;
790  };
791  llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
792  llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
793  Seen.insert(OrigCallee);
794  while (!Worklist.empty()) {
795  CallInfo C = Worklist.pop_back_val();
796  assert(!IsKnownEmitted(S, C.Callee) &&
797  "Worklist should not contain known-emitted functions.");
798  S.CUDAKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
799  EmitDeferredDiags(S, C.Callee);
800 
801  // If this is a template instantiation, explore its callgraph as well:
802  // Non-dependent calls are part of the template's callgraph, while dependent
803  // calls are part of to the instantiation's call graph.
804  if (auto *Templ = C.Callee->getPrimaryTemplate()) {
805  FunctionDecl *TemplFD = Templ->getAsFunction();
806  if (!Seen.count(TemplFD) && !S.CUDAKnownEmittedFns.count(TemplFD)) {
807  Seen.insert(TemplFD);
808  Worklist.push_back(
809  {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
810  }
811  }
812 
813  // Add all functions called by Callee to our worklist.
814  auto CGIt = S.CUDACallGraph.find(C.Callee);
815  if (CGIt == S.CUDACallGraph.end())
816  continue;
817 
818  for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
819  CGIt->second) {
820  FunctionDecl *NewCallee = FDLoc.first;
821  SourceLocation CallLoc = FDLoc.second;
822  if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
823  continue;
824  Seen.insert(NewCallee);
825  Worklist.push_back(
826  {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
827  }
828 
829  // C.Callee is now known-emitted, so we no longer need to maintain its list
830  // of callees in CUDACallGraph.
831  S.CUDACallGraph.erase(CGIt);
832  }
833 }
834 
836  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
837  assert(Callee && "Callee may not be null.");
838  // FIXME: Is bailing out early correct here? Should we instead assume that
839  // the caller is a global initializer?
840  FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext);
841  if (!Caller)
842  return true;
843 
844  // If the caller is known-emitted, mark the callee as known-emitted.
845  // Otherwise, mark the call in our call graph so we can traverse it later.
846  bool CallerKnownEmitted = IsKnownEmitted(*this, Caller);
847  if (CallerKnownEmitted) {
848  // Host-side references to a __global__ function refer to the stub, so the
849  // function itself is never emitted and therefore should not be marked.
850  if (getLangOpts().CUDAIsDevice || IdentifyCUDATarget(Callee) != CFT_Global)
851  MarkKnownEmitted(*this, Caller, Callee, Loc);
852  } else {
853  // If we have
854  // host fn calls kernel fn calls host+device,
855  // the HD function does not get instantiated on the host. We model this by
856  // omitting at the call to the kernel from the callgraph. This ensures
857  // that, when compiling for host, only HD functions actually called from the
858  // host get marked as known-emitted.
859  if (getLangOpts().CUDAIsDevice || IdentifyCUDATarget(Callee) != CFT_Global)
860  CUDACallGraph[Caller].insert({Callee, Loc});
861  }
862 
863  CUDADiagBuilder::Kind DiagKind = [&] {
864  switch (IdentifyCUDAPreference(Caller, Callee)) {
865  case CFP_Never:
867  case CFP_WrongSide:
868  assert(Caller && "WrongSide calls require a non-null caller");
869  // If we know the caller will be emitted, we know this wrong-side call
870  // will be emitted, so it's an immediate error. Otherwise, defer the
871  // error until we know the caller is emitted.
872  return CallerKnownEmitted ? CUDADiagBuilder::K_ImmediateWithCallStack
874  default:
875  return CUDADiagBuilder::K_Nop;
876  }
877  }();
878 
879  if (DiagKind == CUDADiagBuilder::K_Nop)
880  return true;
881 
882  // Avoid emitting this error twice for the same location. Using a hashtable
883  // like this is unfortunate, but because we must continue parsing as normal
884  // after encountering a deferred error, it's otherwise very tricky for us to
885  // ensure that we only emit this deferred error once.
886  if (!LocsWithCUDACallDiags.insert({Caller, Loc}).second)
887  return true;
888 
889  CUDADiagBuilder(DiagKind, Loc, diag::err_ref_bad_target, Caller, *this)
890  << IdentifyCUDATarget(Callee) << Callee << IdentifyCUDATarget(Caller);
891  CUDADiagBuilder(DiagKind, Callee->getLocation(), diag::note_previous_decl,
892  Caller, *this)
893  << Callee;
894  return DiagKind != CUDADiagBuilder::K_Immediate &&
896 }
897 
899  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
900  if (Method->hasAttr<CUDAHostAttr>() || Method->hasAttr<CUDADeviceAttr>())
901  return;
902  FunctionDecl *CurFn = dyn_cast<FunctionDecl>(CurContext);
903  if (!CurFn)
904  return;
905  CUDAFunctionTarget Target = IdentifyCUDATarget(CurFn);
906  if (Target == CFT_Global || Target == CFT_Device) {
907  Method->addAttr(CUDADeviceAttr::CreateImplicit(Context));
908  } else if (Target == CFT_HostDevice) {
909  Method->addAttr(CUDADeviceAttr::CreateImplicit(Context));
910  Method->addAttr(CUDAHostAttr::CreateImplicit(Context));
911  }
912 }
913 
915  const LookupResult &Previous) {
916  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
917  CUDAFunctionTarget NewTarget = IdentifyCUDATarget(NewFD);
918  for (NamedDecl *OldND : Previous) {
919  FunctionDecl *OldFD = OldND->getAsFunction();
920  if (!OldFD)
921  continue;
922 
923  CUDAFunctionTarget OldTarget = IdentifyCUDATarget(OldFD);
924  // Don't allow HD and global functions to overload other functions with the
925  // same signature. We allow overloading based on CUDA attributes so that
926  // functions can have different implementations on the host and device, but
927  // HD/global functions "exist" in some sense on both the host and device, so
928  // should have the same implementation on both sides.
929  if (NewTarget != OldTarget &&
930  ((NewTarget == CFT_HostDevice) || (OldTarget == CFT_HostDevice) ||
931  (NewTarget == CFT_Global) || (OldTarget == CFT_Global)) &&
932  !IsOverload(NewFD, OldFD, /* UseMemberUsingDeclRules = */ false,
933  /* ConsiderCudaAttrs = */ false)) {
934  Diag(NewFD->getLocation(), diag::err_cuda_ovl_target)
935  << NewTarget << NewFD->getDeclName() << OldTarget << OldFD;
936  Diag(OldFD->getLocation(), diag::note_previous_declaration);
937  NewFD->setInvalidDecl();
938  break;
939  }
940  }
941 }
942 
943 template <typename AttrTy>
944 static void copyAttrIfPresent(Sema &S, FunctionDecl *FD,
945  const FunctionDecl &TemplateFD) {
946  if (AttrTy *Attribute = TemplateFD.getAttr<AttrTy>()) {
947  AttrTy *Clone = Attribute->clone(S.Context);
948  Clone->setInherited(true);
949  FD->addAttr(Clone);
950  }
951 }
952 
954  const FunctionTemplateDecl &TD) {
955  const FunctionDecl &TemplateFD = *TD.getTemplatedDecl();
956  copyAttrIfPresent<CUDAGlobalAttr>(*this, FD, TemplateFD);
957  copyAttrIfPresent<CUDAHostAttr>(*this, FD, TemplateFD);
958  copyAttrIfPresent<CUDADeviceAttr>(*this, FD, TemplateFD);
959 }
Defines the clang::ASTContext interface.
FunctionDecl * getDefinition()
Get the definition for this declaration.
Definition: Decl.h:1989
Represents a function declaration or definition.
Definition: Decl.h:1714
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, llvm::MapVector< CanonicalDeclPtr< FunctionDecl >, SourceLocation > > CUDACallGraph
A partial call graph maintained during CUDA compilation to support deferred diagnostics.
Definition: Sema.h:9963
A (possibly-)qualified type.
Definition: Type.h:655
base_class_range bases()
Definition: DeclCXX.h:811
AttributeList * getNext() const
bool CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee)
Check whether we&#39;re allowed to call Callee from the current context.
Definition: SemaCUDA.cpp:835
Emit the diagnostic immediately (i.e., behave like Sema::Diag()).
Definition: Sema.h:9985
Create a deferred diagnostic, which is emitted only if the function it&#39;s attached to is codegen&#39;ed...
Definition: Sema.h:9993
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition: Decl.h:2088
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID)
Emit a diagnostic.
Definition: Sema.h:1270
bool isDiscardableGVALinkage(GVALinkage L)
Definition: Linkage.h:82
bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool IsForUsingDecl, bool ConsiderCudaAttrs=true)
const DiagnosticBuilder & setForceEmit() const
Forces the diagnostic to be emitted.
Definition: Diagnostic.h:1133
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
Definition: Diagnostic.h:1294
Represents a call to a C++ constructor.
Definition: ExprCXX.h:1239
bool isDefined(const FunctionDecl *&Definition) const
Returns true if the function has a definition that does not need to be instantiated.
Definition: Decl.cpp:2651
bool inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, CXXSpecialMember CSM, CXXMethodDecl *MemberDecl, bool ConstRHS, bool Diagnose)
Given a implicit special member, infer its CUDA target from the calls it needs to make to underlying ...
Definition: SemaCUDA.cpp:265
Represents a C++ constructor within a class.
Definition: DeclCXX.h:2463
void maybeAddCUDAHostDeviceAttrs(FunctionDecl *FD, const LookupResult &Previous)
May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD, depending on FD and the current co...
Definition: SemaCUDA.cpp:540
void MarkFunctionReferenced(SourceLocation Loc, FunctionDecl *Func, bool MightBeOdrUse=true)
Mark a function referenced, and check whether it is odr-used (C++ [basic.def.odr]p2, C99 6.9p3)
Definition: SemaExpr.cpp:14243
bool PopForceCUDAHostDevice()
Decrements our count of the number of times we&#39;ve seen a pragma forcing functions to be host device...
Definition: SemaCUDA.cpp:32
Represents a variable declaration or definition.
Definition: Decl.h:812
PartialDiagnostic PDiag(unsigned DiagID=0)
Build a partial diagnostic.
Definition: SemaInternal.h:25
DiagnosticsEngine & Diags
Definition: Sema.h:320
const T * getAs() const
Member-template getAs<specific type>&#39;.
Definition: Type.h:6456
CUDAFunctionPreference
Definition: Sema.h:10083
bool isInvalidDecl() const
Definition: DeclBase.h:547
Defines the clang::Expr interface and subclasses for C++ expressions.
ExprResult ActOnCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false)
ActOnCallExpr - Handle a call to Fn with the specified array of arguments.
Definition: SemaExpr.cpp:5282
DeclarationName getDeclName() const
Get the actual, stored name of the declaration, which may be a special name.
Definition: Decl.h:297
Kind getKind() const
bool hasTrivialBody() const
Returns whether the function has a trivial body that does not require any specific codegen...
Definition: Decl.cpp:2637
field_range fields() const
Definition: Decl.h:3764
void CUDASetLambdaAttrs(CXXMethodDecl *Method)
Set device or host device attributes on the given lambda operator() method.
Definition: SemaCUDA.cpp:898
Represents a member of a struct/union/class.
Definition: Decl.h:2521
CUDADiagBuilder(Kind K, SourceLocation Loc, unsigned DiagID, FunctionDecl *Fn, Sema &S)
Definition: SemaCUDA.cpp:613
bool isReferenceType() const
Definition: Type.h:6061
CUDAFunctionTarget IdentifyCUDATarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)
Determines whether the given function is a CUDA device/host/kernel/etc.
Definition: SemaCUDA.cpp:106
Diagnostic builder for CUDA errors which may or may not be deferred.
Definition: Sema.h:9979
static void EmitCallStackNotes(Sema &S, FunctionDecl *FD)
Definition: SemaCUDA.cpp:634
SpecialMemberOverloadResult - The overloading result for a special member function.
Definition: Sema.h:1025
ExprResult ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc, MultiExprArg ExecConfig, SourceLocation GGGLoc)
Definition: SemaCUDA.cpp:40
Represents the results of name lookup.
Definition: Lookup.h:47
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, std::vector< PartialDiagnosticAt > > CUDADeferredDiags
Diagnostics that are emitted only if we discover that the given function must be codegen&#39;ed.
Definition: Sema.h:9930
Scope - A scope is a transient data structure that is used while parsing the program.
Definition: Scope.h:40
bool isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD)
Definition: SemaCUDA.cpp:393
const LangOptions & getLangOpts() const
Definition: Sema.h:1193
bool isAbstract() const
Determine whether this class has a pure virtual function.
Definition: DeclCXX.h:1334
void InstantiateFunctionDefinition(SourceLocation PointOfInstantiation, FunctionDecl *Function, bool Recursive=false, bool DefinitionRequired=false, bool AtEndOfTU=false)
Instantiate the definition of the given function from its template.
DiagnosticsEngine & getDiagnostics() const
Definition: Sema.h:1197
CXXSpecialMember
Kinds of C++ special members.
Definition: Sema.h:1129
bool hasAttr() const
Definition: DeclBase.h:536
Sema - This implements semantic analysis and AST building for C.
Definition: Sema.h:276
A little helper class used to produce diagnostics.
Definition: Diagnostic.h:1042
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
Definition: Type.cpp:1590
bool isDynamicClass() const
Definition: DeclCXX.h:789
llvm::DenseSet< FunctionDeclAndLoc > LocsWithCUDACallDiags
FunctionDecls and SourceLocations for which CheckCUDACall has emitted a (maybe deferred) "bad call" d...
Definition: Sema.h:9942
Expr - This represents one expression.
Definition: Expr.h:106
Emit no diagnostics.
Definition: Sema.h:9983
void PushForceCUDAHostDevice()
Increments our count of the number of times we&#39;ve seen a pragma forcing functions to be host device...
Definition: SemaCUDA.cpp:27
bool isVariadic() const
Whether this function is variadic.
Definition: Decl.cpp:2620
bool isInSystemHeader(SourceLocation Loc) const
Returns if a SourceLocation is in a system header.
const FunctionProtoType * T
StateNode * Previous
Represents a C++ destructor within a class.
Definition: DeclCXX.h:2686
void setInvalidDecl(bool Invalid=true)
setInvalidDecl - Indicates the Decl had a semantic error.
Definition: DeclBase.cpp:132
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition: DeclBase.h:552
Defines the clang::Preprocessor interface.
bool isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *CD)
Definition: SemaCUDA.cpp:427
bool isDependentContext() const
Determines whether this context is dependent on a template parameter.
Definition: DeclBase.cpp:1040
bool isTrivial() const
Whether this function is "trivial" in some specialized C++ senses.
Definition: Decl.h:2050
decl_type * getFirstDecl()
Return the first declaration of this declaration or itself if this is the only declaration.
Definition: Redeclarable.h:220
llvm::DenseMap< CanonicalDeclPtr< FunctionDecl >, FunctionDeclAndLoc > CUDAKnownEmittedFns
An inverse call graph, mapping known-emitted functions to one of their known-emitted callers (plus th...
Definition: Sema.h:9951
AttrVec & getAttrs()
Definition: DeclBase.h:478
bool hasAttrs() const
Definition: DeclBase.h:472
RecordDecl * getDecl() const
Definition: Type.h:4082
void addAttr(Attr *A)
Definition: DeclBase.h:485
void EraseUnwantedCUDAMatches(const FunctionDecl *Caller, SmallVectorImpl< std::pair< DeclAccessPair, FunctionDecl *>> &Matches)
Finds a function in Matches with highest calling priority from Caller context and erases all function...
Definition: SemaCUDA.cpp:213
void Emit(const DiagnosticBuilder &DB) const
void checkAllowedCUDAInitializer(VarDecl *VD)
Definition: SemaCUDA.cpp:475
ActionResult - This structure is used while parsing/acting on expressions, stmts, etc...
Definition: Ownership.h:157
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition: DeclBase.cpp:218
ASTContext & getASTContext() const
Definition: Sema.h:1200
FunctionDecl * getTemplatedDecl() const
Get the underlying function declaration of the template.
Encodes a location in the source.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
std::pair< SourceLocation, PartialDiagnostic > PartialDiagnosticAt
A partial diagnostic along with the source location where this diagnostic occurs. ...
Represents a static or instance method of a struct/union/class.
Definition: DeclCXX.h:2031
static bool hasAttr(const FunctionDecl *D, bool IgnoreImplicitAttr)
Definition: SemaCUDA.cpp:98
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition: Decl.h:1075
static bool resolveCalleeCUDATargetConflict(Sema::CUDAFunctionTarget Target1, Sema::CUDAFunctionTarget Target2, Sema::CUDAFunctionTarget *ResolvedTarget)
When an implicitly-declared special member has to invoke more than one base/field special member...
Definition: SemaCUDA.cpp:245
CUDADiagBuilder CUDADiagIfHostCode(SourceLocation Loc, unsigned DiagID)
Creates a CUDADiagBuilder that emits the diagnostic if the current context is "used as host code"...
Definition: SemaCUDA.cpp:722
FunctionDecl * getcudaConfigureCallDecl()
Definition: ASTContext.h:1257
CUDAFunctionTarget CurrentCUDATarget()
Gets the CUDA target for the current context.
Definition: Sema.h:10077
Dataflow Directional Tag Classes.
Level getDiagnosticLevel(unsigned DiagID, SourceLocation Loc) const
Based on the way the client configured the DiagnosticsEngine object, classify the specified diagnosti...
Definition: Diagnostic.h:833
const Expr * getInit() const
Definition: Decl.h:1217
const CXXRecordDecl * getParent() const
Returns the parent of this method declaration, which is the class in which this method is defined...
Definition: DeclCXX.h:2151
bool isTemplateInstantiation() const
Determines if the given function was instantiated from a function template.
Definition: Decl.cpp:3326
void checkCUDATargetOverload(FunctionDecl *NewFD, const LookupResult &Previous)
Check whether NewFD is a valid overload for CUDA.
Definition: SemaCUDA.cpp:914
SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D, CXXSpecialMember SM, bool ConstArg, bool VolatileArg, bool RValueThis, bool ConstThis, bool VolatileThis)
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
Definition: Type.h:4072
CUDAFunctionPreference IdentifyCUDAPreference(const FunctionDecl *Caller, const FunctionDecl *Callee)
Identifies relative preference of a given Caller/Callee combination, based on their host/device attri...
Definition: SemaCUDA.cpp:162
Represents a C++ base or member initializer.
Definition: DeclCXX.h:2238
bool isConstantInitializer(ASTContext &Ctx, bool ForRef, const Expr **Culprit=nullptr) const
isConstantInitializer - Returns true if this expression can be emitted to IR as a constant...
Definition: Expr.cpp:2788
T * getAttr() const
Definition: DeclBase.h:532
bool isStaticLocal() const
Returns true if a variable with function scope is a static local variable.
Definition: Decl.h:1057
Represents a base class of a C++ class.
Definition: DeclCXX.h:192
static bool IsKnownEmitted(Sema &S, FunctionDecl *FD)
Definition: SemaCUDA.cpp:662
static void EmitDeferredDiags(Sema &S, FunctionDecl *FD)
Definition: SemaCUDA.cpp:749
Represents a C++ struct/union/class.
Definition: DeclCXX.h:300
static void MarkKnownEmitted(Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee, SourceLocation OrigLoc)
Definition: SemaCUDA.cpp:775
CUDAFunctionTarget
Definition: Sema.h:10059
DeclContext * CurContext
CurContext - This is the current declaration context of parsing.
Definition: Sema.h:330
SourceManager & getSourceManager() const
Definition: Sema.h:1198
iterator end() const
Definition: Lookup.h:325
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition: Stmt.cpp:266
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
Definition: Expr.h:2283
ExprResult ExprError()
Definition: Ownership.h:283
A reference to a declared variable, function, enum, etc.
Definition: Expr.h:972
Emit the diagnostic immediately, and, if it&#39;s a warning or error, also emit a call stack showing how ...
Definition: Sema.h:9989
QualType getType() const
Definition: Decl.h:647
An l-value expression is a reference to an object with independent storage.
Definition: Specifiers.h:114
void inheritCUDATargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD)
Copies target attributes from the template TD to the function FD.
Definition: SemaCUDA.cpp:953
A wrapper class around a pointer that always points to its canonical declaration. ...
Definition: Redeclarable.h:352
ASTContext & Context
Definition: Sema.h:318
This represents a decl that may have a name.
Definition: Decl.h:248
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition: Decl.cpp:2963
bool hasInit() const
Definition: Decl.cpp:2144
static void copyAttrIfPresent(Sema &S, FunctionDecl *FD, const FunctionDecl &TemplateFD)
Definition: SemaCUDA.cpp:944
base_class_range vbases()
Definition: DeclCXX.h:828
Declaration of a template function.
Definition: DeclTemplate.h:968
CUDADiagBuilder CUDADiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)
Creates a CUDADiagBuilder that emits the diagnostic if the current context is "used as device code"...
Definition: SemaCUDA.cpp:695
Attr - This represents one attribute.
Definition: Attr.h:43
SourceLocation getLocation() const
Definition: DeclBase.h:417
Represents a shadow declaration introduced into a scope by a (resolved) using declaration.
Definition: DeclCXX.h:3132
AttributeList - Represents a syntactic attribute.
A RAII object to temporarily push a declaration context.
Definition: Sema.h:705