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