Remove LLVM 8.0.1 files.

1 files changed, 0 insertions, 960 deletions

diff --git a/gnu/llvm/tools/clang/lib/Sema/SemaCUDA.cpp b/gnu/llvm/tools/clang/lib/Sema/SemaCUDA.cpp
deleted file mode 100644
index ffc72889858..00000000000
--- a/gnu/llvm/tools/clang/lib/Sema/SemaCUDA.cpp
+++ /dev/null
@@ -1,960 +0,0 @@
-//===--- SemaCUDA.cpp - Semantic Analysis for CUDA constructs -------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-/// \file
-/// This file implements semantic analysis for CUDA constructs.
-///
-//===----------------------------------------------------------------------===//
-
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/Decl.h"
-#include "clang/AST/ExprCXX.h"
-#include "clang/Lex/Preprocessor.h"
-#include "clang/Sema/Lookup.h"
-#include "clang/Sema/Sema.h"
-#include "clang/Sema/SemaDiagnostic.h"
-#include "clang/Sema/SemaInternal.h"
-#include "clang/Sema/Template.h"
-#include "llvm/ADT/Optional.h"
-#include "llvm/ADT/SmallVector.h"
-using namespace clang;
-
-void Sema::PushForceCUDAHostDevice() {
-  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
-  ForceCUDAHostDeviceDepth++;
-}
-
-bool Sema::PopForceCUDAHostDevice() {
-  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
-  if (ForceCUDAHostDeviceDepth == 0)
-    return false;
-  ForceCUDAHostDeviceDepth--;
-  return true;
-}
-
-ExprResult Sema::ActOnCUDAExecConfigExpr(Scope *S, SourceLocation LLLLoc,
-                                         MultiExprArg ExecConfig,
-                                         SourceLocation GGGLoc) {
-  FunctionDecl *ConfigDecl = Context.getcudaConfigureCallDecl();
-  if (!ConfigDecl)
-    return ExprError(
-        Diag(LLLLoc, diag::err_undeclared_var_use)
-        << (getLangOpts().HIP ? "hipConfigureCall" : "cudaConfigureCall"));
-  QualType ConfigQTy = ConfigDecl->getType();
-
-  DeclRefExpr *ConfigDR = new (Context)
-      DeclRefExpr(Context, ConfigDecl, false, ConfigQTy, VK_LValue, LLLLoc);
-  MarkFunctionReferenced(LLLLoc, ConfigDecl);
-
-  return ActOnCallExpr(S, ConfigDR, LLLLoc, ExecConfig, GGGLoc, nullptr,
-                       /*IsExecConfig=*/true);
-}
-
-Sema::CUDAFunctionTarget
-Sema::IdentifyCUDATarget(const ParsedAttributesView &Attrs) {
-  bool HasHostAttr = false;
-  bool HasDeviceAttr = false;
-  bool HasGlobalAttr = false;
-  bool HasInvalidTargetAttr = false;
-  for (const ParsedAttr &AL : Attrs) {
-    switch (AL.getKind()) {
-    case ParsedAttr::AT_CUDAGlobal:
-      HasGlobalAttr = true;
-      break;
-    case ParsedAttr::AT_CUDAHost:
-      HasHostAttr = true;
-      break;
-    case ParsedAttr::AT_CUDADevice:
-      HasDeviceAttr = true;
-      break;
-    case ParsedAttr::AT_CUDAInvalidTarget:
-      HasInvalidTargetAttr = true;
-      break;
-    default:
-      break;
-    }
-  }
-
-  if (HasInvalidTargetAttr)
-    return CFT_InvalidTarget;
-
-  if (HasGlobalAttr)
-    return CFT_Global;
-
-  if (HasHostAttr && HasDeviceAttr)
-    return CFT_HostDevice;
-
-  if (HasDeviceAttr)
-    return CFT_Device;
-
-  return CFT_Host;
-}
-
-template <typename A>
-static bool hasAttr(const FunctionDecl *D, bool IgnoreImplicitAttr) {
-  return D->hasAttrs() && llvm::any_of(D->getAttrs(), [&](Attr *Attribute) {
-           return isa<A>(Attribute) &&
-                  !(IgnoreImplicitAttr && Attribute->isImplicit());
-         });
-}
-
-/// IdentifyCUDATarget - Determine the CUDA compilation target for this function
-Sema::CUDAFunctionTarget Sema::IdentifyCUDATarget(const FunctionDecl *D,
-                                                  bool IgnoreImplicitHDAttr) {
-  // Code that lives outside a function is run on the host.
-  if (D == nullptr)
-    return CFT_Host;
-
-  if (D->hasAttr<CUDAInvalidTargetAttr>())
-    return CFT_InvalidTarget;
-
-  if (D->hasAttr<CUDAGlobalAttr>())
-    return CFT_Global;
-
-  if (hasAttr<CUDADeviceAttr>(D, IgnoreImplicitHDAttr)) {
-    if (hasAttr<CUDAHostAttr>(D, IgnoreImplicitHDAttr))
-      return CFT_HostDevice;
-    return CFT_Device;
-  } else if (hasAttr<CUDAHostAttr>(D, IgnoreImplicitHDAttr)) {
-    return CFT_Host;
-  } else if (D->isImplicit() && !IgnoreImplicitHDAttr) {
-    // Some implicit declarations (like intrinsic functions) are not marked.
-    // Set the most lenient target on them for maximal flexibility.
-    return CFT_HostDevice;
-  }
-
-  return CFT_Host;
-}
-
-// * CUDA Call preference table
-//
-// F - from,
-// T - to
-// Ph - preference in host mode
-// Pd - preference in device mode
-// H  - handled in (x)
-// Preferences: N:native, SS:same side, HD:host-device, WS:wrong side, --:never.
-//
-// | F  | T  | Ph  | Pd  |  H  |
-// |----+----+-----+-----+-----+
-// | d  | d  | N   | N   | (c) |
-// | d  | g  | --  | --  | (a) |
-// | d  | h  | --  | --  | (e) |
-// | d  | hd | HD  | HD  | (b) |
-// | g  | d  | N   | N   | (c) |
-// | g  | g  | --  | --  | (a) |
-// | g  | h  | --  | --  | (e) |
-// | g  | hd | HD  | HD  | (b) |
-// | h  | d  | --  | --  | (e) |
-// | h  | g  | N   | N   | (c) |
-// | h  | h  | N   | N   | (c) |
-// | h  | hd | HD  | HD  | (b) |
-// | hd | d  | WS  | SS  | (d) |
-// | hd | g  | SS  | --  |(d/a)|
-// | hd | h  | SS  | WS  | (d) |
-// | hd | hd | HD  | HD  | (b) |
-
-Sema::CUDAFunctionPreference
-Sema::IdentifyCUDAPreference(const FunctionDecl *Caller,
-                             const FunctionDecl *Callee) {
-  assert(Callee && "Callee must be valid.");
-  CUDAFunctionTarget CallerTarget = IdentifyCUDATarget(Caller);
-  CUDAFunctionTarget CalleeTarget = IdentifyCUDATarget(Callee);
-
-  // If one of the targets is invalid, the check always fails, no matter what
-  // the other target is.
-  if (CallerTarget == CFT_InvalidTarget || CalleeTarget == CFT_InvalidTarget)
-    return CFP_Never;
-
-  // (a) Can't call global from some contexts until we support CUDA's
-  // dynamic parallelism.
-  if (CalleeTarget == CFT_Global &&
-      (CallerTarget == CFT_Global || CallerTarget == CFT_Device))
-    return CFP_Never;
-
-  // (b) Calling HostDevice is OK for everyone.
-  if (CalleeTarget == CFT_HostDevice)
-    return CFP_HostDevice;
-
-  // (c) Best case scenarios
-  if (CalleeTarget == CallerTarget ||
-      (CallerTarget == CFT_Host && CalleeTarget == CFT_Global) ||
-      (CallerTarget == CFT_Global && CalleeTarget == CFT_Device))
-    return CFP_Native;
-
-  // (d) HostDevice behavior depends on compilation mode.
-  if (CallerTarget == CFT_HostDevice) {
-    // It's OK to call a compilation-mode matching function from an HD one.
-    if ((getLangOpts().CUDAIsDevice && CalleeTarget == CFT_Device) ||
-        (!getLangOpts().CUDAIsDevice &&
-         (CalleeTarget == CFT_Host || CalleeTarget == CFT_Global)))
-      return CFP_SameSide;
-
-    // Calls from HD to non-mode-matching functions (i.e., to host functions
-    // when compiling in device mode or to device functions when compiling in
-    // host mode) are allowed at the sema level, but eventually rejected if
-    // they're ever codegened.  TODO: Reject said calls earlier.
-    return CFP_WrongSide;
-  }
-
-  // (e) Calling across device/host boundary is not something you should do.
-  if ((CallerTarget == CFT_Host && CalleeTarget == CFT_Device) ||
-      (CallerTarget == CFT_Device && CalleeTarget == CFT_Host) ||
-      (CallerTarget == CFT_Global && CalleeTarget == CFT_Host))
-    return CFP_Never;
-
-  llvm_unreachable("All cases should've been handled by now.");
-}
-
-void Sema::EraseUnwantedCUDAMatches(
-    const FunctionDecl *Caller,
-    SmallVectorImpl<std::pair<DeclAccessPair, FunctionDecl *>> &Matches) {
-  if (Matches.size() <= 1)
-    return;
-
-  using Pair = std::pair<DeclAccessPair, FunctionDecl*>;
-
-  // Gets the CUDA function preference for a call from Caller to Match.
-  auto GetCFP = [&](const Pair &Match) {
-    return IdentifyCUDAPreference(Caller, Match.second);
-  };
-
-  // Find the best call preference among the functions in Matches.
-  CUDAFunctionPreference BestCFP = GetCFP(*std::max_element(
-      Matches.begin(), Matches.end(),
-      [&](const Pair &M1, const Pair &M2) { return GetCFP(M1) < GetCFP(M2); }));
-
-  // Erase all functions with lower priority.
-  llvm::erase_if(Matches,
-                 [&](const Pair &Match) { return GetCFP(Match) < BestCFP; });
-}
-
-/// When an implicitly-declared special member has to invoke more than one
-/// base/field special member, conflicts may occur in the targets of these
-/// members. For example, if one base's member __host__ and another's is
-/// __device__, it's a conflict.
-/// This function figures out if the given targets \param Target1 and
-/// \param Target2 conflict, and if they do not it fills in
-/// \param ResolvedTarget with a target that resolves for both calls.
-/// \return true if there's a conflict, false otherwise.
-static bool
-resolveCalleeCUDATargetConflict(Sema::CUDAFunctionTarget Target1,
-                                Sema::CUDAFunctionTarget Target2,
-                                Sema::CUDAFunctionTarget *ResolvedTarget) {
-  // Only free functions and static member functions may be global.
-  assert(Target1 != Sema::CFT_Global);
-  assert(Target2 != Sema::CFT_Global);
-
-  if (Target1 == Sema::CFT_HostDevice) {
-    *ResolvedTarget = Target2;
-  } else if (Target2 == Sema::CFT_HostDevice) {
-    *ResolvedTarget = Target1;
-  } else if (Target1 != Target2) {
-    return true;
-  } else {
-    *ResolvedTarget = Target1;
-  }
-
-  return false;
-}
-
-bool Sema::inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl,
-                                                   CXXSpecialMember CSM,
-                                                   CXXMethodDecl *MemberDecl,
-                                                   bool ConstRHS,
-                                                   bool Diagnose) {
-  llvm::Optional<CUDAFunctionTarget> InferredTarget;
-
-  // We're going to invoke special member lookup; mark that these special
-  // members are called from this one, and not from its caller.
-  ContextRAII MethodContext(*this, MemberDecl);
-
-  // Look for special members in base classes that should be invoked from here.
-  // Infer the target of this member base on the ones it should call.
-  // Skip direct and indirect virtual bases for abstract classes.
-  llvm::SmallVector<const CXXBaseSpecifier *, 16> Bases;
-  for (const auto &B : ClassDecl->bases()) {
-    if (!B.isVirtual()) {
-      Bases.push_back(&B);
-    }
-  }
-
-  if (!ClassDecl->isAbstract()) {
-    for (const auto &VB : ClassDecl->vbases()) {
-      Bases.push_back(&VB);
-    }
-  }
-
-  for (const auto *B : Bases) {
-    const RecordType *BaseType = B->getType()->getAs<RecordType>();
-    if (!BaseType) {
-      continue;
-    }
-
-    CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseType->getDecl());
-    Sema::SpecialMemberOverloadResult SMOR =
-        LookupSpecialMember(BaseClassDecl, CSM,
-                            /* ConstArg */ ConstRHS,
-                            /* VolatileArg */ false,
-                            /* RValueThis */ false,
-                            /* ConstThis */ false,
-                            /* VolatileThis */ false);
-
-    if (!SMOR.getMethod())
-      continue;
-
-    CUDAFunctionTarget BaseMethodTarget = IdentifyCUDATarget(SMOR.getMethod());
-    if (!InferredTarget.hasValue()) {
-      InferredTarget = BaseMethodTarget;
-    } else {
-      bool ResolutionError = resolveCalleeCUDATargetConflict(
-          InferredTarget.getValue(), BaseMethodTarget,
-          InferredTarget.getPointer());
-      if (ResolutionError) {
-        if (Diagnose) {
-          Diag(ClassDecl->getLocation(),
-               diag::note_implicit_member_target_infer_collision)
-              << (unsigned)CSM << InferredTarget.getValue() << BaseMethodTarget;
-        }
-        MemberDecl->addAttr(CUDAInvalidTargetAttr::CreateImplicit(Context));
-        return true;
-      }
-    }
-  }
-
-  // Same as for bases, but now for special members of fields.
-  for (const auto *F : ClassDecl->fields()) {
-    if (F->isInvalidDecl()) {
-      continue;
-    }
-
-    const RecordType *FieldType =
-        Context.getBaseElementType(F->getType())->getAs<RecordType>();
-    if (!FieldType) {
-      continue;
-    }
-
-    CXXRecordDecl *FieldRecDecl = cast<CXXRecordDecl>(FieldType->getDecl());
-    Sema::SpecialMemberOverloadResult SMOR =
-        LookupSpecialMember(FieldRecDecl, CSM,
-                            /* ConstArg */ ConstRHS && !F->isMutable(),
-                            /* VolatileArg */ false,
-                            /* RValueThis */ false,
-                            /* ConstThis */ false,
-                            /* VolatileThis */ false);
-
-    if (!SMOR.getMethod())
-      continue;
-
-    CUDAFunctionTarget FieldMethodTarget =
-        IdentifyCUDATarget(SMOR.getMethod());
-    if (!InferredTarget.hasValue()) {
-      InferredTarget = FieldMethodTarget;
-    } else {
-      bool ResolutionError = resolveCalleeCUDATargetConflict(
-          InferredTarget.getValue(), FieldMethodTarget,
-          InferredTarget.getPointer());
-      if (ResolutionError) {
-        if (Diagnose) {
-          Diag(ClassDecl->getLocation(),
-               diag::note_implicit_member_target_infer_collision)
-              << (unsigned)CSM << InferredTarget.getValue()
-              << FieldMethodTarget;
-        }
-        MemberDecl->addAttr(CUDAInvalidTargetAttr::CreateImplicit(Context));
-        return true;
-      }
-    }
-  }
-
-  if (InferredTarget.hasValue()) {
-    if (InferredTarget.getValue() == CFT_Device) {
-      MemberDecl->addAttr(CUDADeviceAttr::CreateImplicit(Context));
-    } else if (InferredTarget.getValue() == CFT_Host) {
-      MemberDecl->addAttr(CUDAHostAttr::CreateImplicit(Context));
-    } else {
-      MemberDecl->addAttr(CUDADeviceAttr::CreateImplicit(Context));
-      MemberDecl->addAttr(CUDAHostAttr::CreateImplicit(Context));
-    }
-  } else {
-    // If no target was inferred, mark this member as __host__ __device__;
-    // it's the least restrictive option that can be invoked from any target.
-    MemberDecl->addAttr(CUDADeviceAttr::CreateImplicit(Context));
-    MemberDecl->addAttr(CUDAHostAttr::CreateImplicit(Context));
-  }
-
-  return false;
-}
-
-bool Sema::isEmptyCudaConstructor(SourceLocation Loc, CXXConstructorDecl *CD) {
-  if (!CD->isDefined() && CD->isTemplateInstantiation())
-    InstantiateFunctionDefinition(Loc, CD->getFirstDecl());
-
-  // (E.2.3.1, CUDA 7.5) A constructor for a class type is considered
-  // empty at a point in the translation unit, if it is either a
-  // trivial constructor
-  if (CD->isTrivial())
-    return true;
-
-  // ... or it satisfies all of the following conditions:
-  // The constructor function has been defined.
-  // The constructor function has no parameters,
-  // and the function body is an empty compound statement.
-  if (!(CD->hasTrivialBody() && CD->getNumParams() == 0))
-    return false;
-
-  // Its class has no virtual functions and no virtual base classes.
-  if (CD->getParent()->isDynamicClass())
-    return false;
-
-  // The only form of initializer allowed is an empty constructor.
-  // This will recursively check all base classes and member initializers
-  if (!llvm::all_of(CD->inits(), [&](const CXXCtorInitializer *CI) {
-        if (const CXXConstructExpr *CE =
-                dyn_cast<CXXConstructExpr>(CI->getInit()))
-          return isEmptyCudaConstructor(Loc, CE->getConstructor());
-        return false;
-      }))
-    return false;
-
-  return true;
-}
-
-bool Sema::isEmptyCudaDestructor(SourceLocation Loc, CXXDestructorDecl *DD) {
-  // No destructor -> no problem.
-  if (!DD)
-    return true;
-
-  if (!DD->isDefined() && DD->isTemplateInstantiation())
-    InstantiateFunctionDefinition(Loc, DD->getFirstDecl());
-
-  // (E.2.3.1, CUDA 7.5) A destructor for a class type is considered
-  // empty at a point in the translation unit, if it is either a
-  // trivial constructor
-  if (DD->isTrivial())
-    return true;
-
-  // ... or it satisfies all of the following conditions:
-  // The destructor function has been defined.
-  // and the function body is an empty compound statement.
-  if (!DD->hasTrivialBody())
-    return false;
-
-  const CXXRecordDecl *ClassDecl = DD->getParent();
-
-  // Its class has no virtual functions and no virtual base classes.
-  if (ClassDecl->isDynamicClass())
-    return false;
-
-  // Only empty destructors are allowed. This will recursively check
-  // destructors for all base classes...
-  if (!llvm::all_of(ClassDecl->bases(), [&](const CXXBaseSpecifier &BS) {
-        if (CXXRecordDecl *RD = BS.getType()->getAsCXXRecordDecl())
-          return isEmptyCudaDestructor(Loc, RD->getDestructor());
-        return true;
-      }))
-    return false;
-
-  // ... and member fields.
-  if (!llvm::all_of(ClassDecl->fields(), [&](const FieldDecl *Field) {
-        if (CXXRecordDecl *RD = Field->getType()
-                                    ->getBaseElementTypeUnsafe()
-                                    ->getAsCXXRecordDecl())
-          return isEmptyCudaDestructor(Loc, RD->getDestructor());
-        return true;
-      }))
-    return false;
-
-  return true;
-}
-
-void Sema::checkAllowedCUDAInitializer(VarDecl *VD) {
-  if (VD->isInvalidDecl() || !VD->hasInit() || !VD->hasGlobalStorage())
-    return;
-  const Expr *Init = VD->getInit();
-  if (VD->hasAttr<CUDADeviceAttr>() || VD->hasAttr<CUDAConstantAttr>() ||
-      VD->hasAttr<CUDASharedAttr>()) {
-    assert(!VD->isStaticLocal() || VD->hasAttr<CUDASharedAttr>());
-    bool AllowedInit = false;
-    if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(Init))
-      AllowedInit =
-          isEmptyCudaConstructor(VD->getLocation(), CE->getConstructor());
-    // We'll allow constant initializers even if it's a non-empty
-    // constructor according to CUDA rules. This deviates from NVCC,
-    // but allows us to handle things like constexpr constructors.
-    if (!AllowedInit &&
-        (VD->hasAttr<CUDADeviceAttr>() || VD->hasAttr<CUDAConstantAttr>()))
-      AllowedInit = VD->getInit()->isConstantInitializer(
-          Context, VD->getType()->isReferenceType());
-
-    // Also make sure that destructor, if there is one, is empty.
-    if (AllowedInit)
-      if (CXXRecordDecl *RD = VD->getType()->getAsCXXRecordDecl())
-        AllowedInit =
-            isEmptyCudaDestructor(VD->getLocation(), RD->getDestructor());
-
-    if (!AllowedInit) {
-      Diag(VD->getLocation(), VD->hasAttr<CUDASharedAttr>()
-                                  ? diag::err_shared_var_init
-                                  : diag::err_dynamic_var_init)
-          << Init->getSourceRange();
-      VD->setInvalidDecl();
-    }
-  } else {
-    // This is a host-side global variable.  Check that the initializer is
-    // callable from the host side.
-    const FunctionDecl *InitFn = nullptr;
-    if (const CXXConstructExpr *CE = dyn_cast<CXXConstructExpr>(Init)) {
-      InitFn = CE->getConstructor();
-    } else if (const CallExpr *CE = dyn_cast<CallExpr>(Init)) {
-      InitFn = CE->getDirectCallee();
-    }
-    if (InitFn) {
-      CUDAFunctionTarget InitFnTarget = IdentifyCUDATarget(InitFn);
-      if (InitFnTarget != CFT_Host && InitFnTarget != CFT_HostDevice) {
-        Diag(VD->getLocation(), diag::err_ref_bad_target_global_initializer)
-            << InitFnTarget << InitFn;
-        Diag(InitFn->getLocation(), diag::note_previous_decl) << InitFn;
-        VD->setInvalidDecl();
-      }
-    }
-  }
-}
-
-// With -fcuda-host-device-constexpr, an unattributed constexpr function is
-// treated as implicitly __host__ __device__, unless:
-//  * it is a variadic function (device-side variadic functions are not
-//    allowed), or
-//  * a __device__ function with this signature was already declared, in which
-//    case in which case we output an error, unless the __device__ decl is in a
-//    system header, in which case we leave the constexpr function unattributed.
-//
-// In addition, all function decls are treated as __host__ __device__ when
-// ForceCUDAHostDeviceDepth > 0 (corresponding to code within a
-//   #pragma clang force_cuda_host_device_begin/end
-// pair).
-void Sema::maybeAddCUDAHostDeviceAttrs(FunctionDecl *NewD,
-                                       const LookupResult &Previous) {
-  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
-
-  if (ForceCUDAHostDeviceDepth > 0) {
-    if (!NewD->hasAttr<CUDAHostAttr>())
-      NewD->addAttr(CUDAHostAttr::CreateImplicit(Context));
-    if (!NewD->hasAttr<CUDADeviceAttr>())
-      NewD->addAttr(CUDADeviceAttr::CreateImplicit(Context));
-    return;
-  }
-
-  if (!getLangOpts().CUDAHostDeviceConstexpr || !NewD->isConstexpr() ||
-      NewD->isVariadic() || NewD->hasAttr<CUDAHostAttr>() ||
-      NewD->hasAttr<CUDADeviceAttr>() || NewD->hasAttr<CUDAGlobalAttr>())
-    return;
-
-  // Is D a __device__ function with the same signature as NewD, ignoring CUDA
-  // attributes?
-  auto IsMatchingDeviceFn = [&](NamedDecl *D) {
-    if (UsingShadowDecl *Using = dyn_cast<UsingShadowDecl>(D))
-      D = Using->getTargetDecl();
-    FunctionDecl *OldD = D->getAsFunction();
-    return OldD && OldD->hasAttr<CUDADeviceAttr>() &&
-           !OldD->hasAttr<CUDAHostAttr>() &&
-           !IsOverload(NewD, OldD, /* UseMemberUsingDeclRules = */ false,
-                       /* ConsiderCudaAttrs = */ false);
-  };
-  auto It = llvm::find_if(Previous, IsMatchingDeviceFn);
-  if (It != Previous.end()) {
-    // We found a __device__ function with the same name and signature as NewD
-    // (ignoring CUDA attrs).  This is an error unless that function is defined
-    // in a system header, in which case we simply return without making NewD
-    // host+device.
-    NamedDecl *Match = *It;
-    if (!getSourceManager().isInSystemHeader(Match->getLocation())) {
-      Diag(NewD->getLocation(),
-           diag::err_cuda_unattributed_constexpr_cannot_overload_device)
-          << NewD;
-      Diag(Match->getLocation(),
-           diag::note_cuda_conflicting_device_function_declared_here);
-    }
-    return;
-  }
-
-  NewD->addAttr(CUDAHostAttr::CreateImplicit(Context));
-  NewD->addAttr(CUDADeviceAttr::CreateImplicit(Context));
-}
-
-// In CUDA, there are some constructs which may appear in semantically-valid
-// code, but trigger errors if we ever generate code for the function in which
-// they appear.  Essentially every construct you're not allowed to use on the
-// device falls into this category, because you are allowed to use these
-// constructs in a __host__ __device__ function, but only if that function is
-// never codegen'ed on the device.
-//
-// To handle semantic checking for these constructs, we keep track of the set of
-// functions we know will be emitted, either because we could tell a priori that
-// they would be emitted, or because they were transitively called by a
-// known-emitted function.
-//
-// We also keep a partial call graph of which not-known-emitted functions call
-// which other not-known-emitted functions.
-//
-// When we see something which is illegal if the current function is emitted
-// (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
-// CheckCUDACall), we first check if the current function is known-emitted.  If
-// so, we immediately output the diagnostic.
-//
-// Otherwise, we "defer" the diagnostic.  It sits in Sema::CUDADeferredDiags
-// until we discover that the function is known-emitted, at which point we take
-// it out of this map and emit the diagnostic.
-
-Sema::CUDADiagBuilder::CUDADiagBuilder(Kind K, SourceLocation Loc,
-                                       unsigned DiagID, FunctionDecl *Fn,
-                                       Sema &S)
-    : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
-      ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
-  switch (K) {
-  case K_Nop:
-    break;
-  case K_Immediate:
-  case K_ImmediateWithCallStack:
-    ImmediateDiag.emplace(S.Diag(Loc, DiagID));
-    break;
-  case K_Deferred:
-    assert(Fn && "Must have a function to attach the deferred diag to.");
-    PartialDiag.emplace(S.PDiag(DiagID));
-    break;
-  }
-}
-
-// Print notes showing how we can reach FD starting from an a priori
-// known-callable function.
-static void EmitCallStackNotes(Sema &S, FunctionDecl *FD) {
-  auto FnIt = S.CUDAKnownEmittedFns.find(FD);
-  while (FnIt != S.CUDAKnownEmittedFns.end()) {
-    DiagnosticBuilder Builder(
-        S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
-    Builder << FnIt->second.FD;
-    Builder.setForceEmit();
-
-    FnIt = S.CUDAKnownEmittedFns.find(FnIt->second.FD);
-  }
-}
-
-Sema::CUDADiagBuilder::~CUDADiagBuilder() {
-  if (ImmediateDiag) {
-    // Emit our diagnostic and, if it was a warning or error, output a callstack
-    // if Fn isn't a priori known-emitted.
-    bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
-                                DiagID, Loc) >= DiagnosticsEngine::Warning;
-    ImmediateDiag.reset(); // Emit the immediate diag.
-    if (IsWarningOrError && ShowCallStack)
-      EmitCallStackNotes(S, Fn);
-  } else if (PartialDiag) {
-    assert(ShowCallStack && "Must always show call stack for deferred diags.");
-    S.CUDADeferredDiags[Fn].push_back({Loc, std::move(*PartialDiag)});
-  }
-}
-
-// Do we know that we will eventually codegen the given function?
-static bool IsKnownEmitted(Sema &S, FunctionDecl *FD) {
-  // Templates are emitted when they're instantiated.
-  if (FD->isDependentContext())
-    return false;
-
-  // When compiling for device, host functions are never emitted.  Similarly,
-  // when compiling for host, device and global functions are never emitted.
-  // (Technically, we do emit a host-side stub for global functions, but this
-  // doesn't count for our purposes here.)
-  Sema::CUDAFunctionTarget T = S.IdentifyCUDATarget(FD);
-  if (S.getLangOpts().CUDAIsDevice && T == Sema::CFT_Host)
-    return false;
-  if (!S.getLangOpts().CUDAIsDevice &&
-      (T == Sema::CFT_Device || T == Sema::CFT_Global))
-    return false;
-
-  // Check whether this function is externally visible -- if so, it's
-  // known-emitted.
-  //
-  // We have to check the GVA linkage of the function's *definition* -- if we
-  // only have a declaration, we don't know whether or not the function will be
-  // emitted, because (say) the definition could include "inline".
-  FunctionDecl *Def = FD->getDefinition();
-
-  if (Def &&
-      !isDiscardableGVALinkage(S.getASTContext().GetGVALinkageForFunction(Def)))
-    return true;
-
-  // Otherwise, the function is known-emitted if it's in our set of
-  // known-emitted functions.
-  return S.CUDAKnownEmittedFns.count(FD) > 0;
-}
-
-Sema::CUDADiagBuilder Sema::CUDADiagIfDeviceCode(SourceLocation Loc,
-                                                 unsigned DiagID) {
-  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
-  CUDADiagBuilder::Kind DiagKind = [&] {
-    switch (CurrentCUDATarget()) {
-    case CFT_Global:
-    case CFT_Device:
-      return CUDADiagBuilder::K_Immediate;
-    case CFT_HostDevice:
-      // An HD function counts as host code if we're compiling for host, and
-      // device code if we're compiling for device.  Defer any errors in device
-      // mode until the function is known-emitted.
-      if (getLangOpts().CUDAIsDevice) {
-        return IsKnownEmitted(*this, dyn_cast<FunctionDecl>(CurContext))
-                   ? CUDADiagBuilder::K_ImmediateWithCallStack
-                   : CUDADiagBuilder::K_Deferred;
-      }
-      return CUDADiagBuilder::K_Nop;
-
-    default:
-      return CUDADiagBuilder::K_Nop;
-    }
-  }();
-  return CUDADiagBuilder(DiagKind, Loc, DiagID,
-                         dyn_cast<FunctionDecl>(CurContext), *this);
-}
-
-Sema::CUDADiagBuilder Sema::CUDADiagIfHostCode(SourceLocation Loc,
-                                               unsigned DiagID) {
-  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
-  CUDADiagBuilder::Kind DiagKind = [&] {
-    switch (CurrentCUDATarget()) {
-    case CFT_Host:
-      return CUDADiagBuilder::K_Immediate;
-    case CFT_HostDevice:
-      // An HD function counts as host code if we're compiling for host, and
-      // device code if we're compiling for device.  Defer any errors in device
-      // mode until the function is known-emitted.
-      if (getLangOpts().CUDAIsDevice)
-        return CUDADiagBuilder::K_Nop;
-
-      return IsKnownEmitted(*this, dyn_cast<FunctionDecl>(CurContext))
-                 ? CUDADiagBuilder::K_ImmediateWithCallStack
-                 : CUDADiagBuilder::K_Deferred;
-    default:
-      return CUDADiagBuilder::K_Nop;
-    }
-  }();
-  return CUDADiagBuilder(DiagKind, Loc, DiagID,
-                         dyn_cast<FunctionDecl>(CurContext), *this);
-}
-
-// Emit any deferred diagnostics for FD and erase them from the map in which
-// they're stored.
-static void EmitDeferredDiags(Sema &S, FunctionDecl *FD) {
-  auto It = S.CUDADeferredDiags.find(FD);
-  if (It == S.CUDADeferredDiags.end())
-    return;
-  bool HasWarningOrError = false;
-  for (PartialDiagnosticAt &PDAt : It->second) {
-    const SourceLocation &Loc = PDAt.first;
-    const PartialDiagnostic &PD = PDAt.second;
-    HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
-                             PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
-    DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
-    Builder.setForceEmit();
-    PD.Emit(Builder);
-  }
-  S.CUDADeferredDiags.erase(It);
-
-  // FIXME: Should this be called after every warning/error emitted in the loop
-  // above, instead of just once per function?  That would be consistent with
-  // how we handle immediate errors, but it also seems like a bit much.
-  if (HasWarningOrError)
-    EmitCallStackNotes(S, FD);
-}
-
-// Indicate that this function (and thus everything it transtively calls) will
-// be codegen'ed, and emit any deferred diagnostics on this function and its
-// (transitive) callees.
-static void MarkKnownEmitted(Sema &S, FunctionDecl *OrigCaller,
-                             FunctionDecl *OrigCallee, SourceLocation OrigLoc) {
-  // Nothing to do if we already know that FD is emitted.
-  if (IsKnownEmitted(S, OrigCallee)) {
-    assert(!S.CUDACallGraph.count(OrigCallee));
-    return;
-  }
-
-  // We've just discovered that OrigCallee is known-emitted.  Walk our call
-  // graph to see what else we can now discover also must be emitted.
-
-  struct CallInfo {
-    FunctionDecl *Caller;
-    FunctionDecl *Callee;
-    SourceLocation Loc;
-  };
-  llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
-  llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
-  Seen.insert(OrigCallee);
-  while (!Worklist.empty()) {
-    CallInfo C = Worklist.pop_back_val();
-    assert(!IsKnownEmitted(S, C.Callee) &&
-           "Worklist should not contain known-emitted functions.");
-    S.CUDAKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
-    EmitDeferredDiags(S, C.Callee);
-
-    // If this is a template instantiation, explore its callgraph as well:
-    // Non-dependent calls are part of the template's callgraph, while dependent
-    // calls are part of to the instantiation's call graph.
-    if (auto *Templ = C.Callee->getPrimaryTemplate()) {
-      FunctionDecl *TemplFD = Templ->getAsFunction();
-      if (!Seen.count(TemplFD) && !S.CUDAKnownEmittedFns.count(TemplFD)) {
-        Seen.insert(TemplFD);
-        Worklist.push_back(
-            {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
-      }
-    }
-
-    // Add all functions called by Callee to our worklist.
-    auto CGIt = S.CUDACallGraph.find(C.Callee);
-    if (CGIt == S.CUDACallGraph.end())
-      continue;
-
-    for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
-         CGIt->second) {
-      FunctionDecl *NewCallee = FDLoc.first;
-      SourceLocation CallLoc = FDLoc.second;
-      if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
-        continue;
-      Seen.insert(NewCallee);
-      Worklist.push_back(
-          {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
-    }
-
-    // C.Callee is now known-emitted, so we no longer need to maintain its list
-    // of callees in CUDACallGraph.
-    S.CUDACallGraph.erase(CGIt);
-  }
-}
-
-bool Sema::CheckCUDACall(SourceLocation Loc, FunctionDecl *Callee) {
-  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
-  assert(Callee && "Callee may not be null.");
-  // FIXME: Is bailing out early correct here?  Should we instead assume that
-  // the caller is a global initializer?
-  FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext);
-  if (!Caller)
-    return true;
-
-  // If the caller is known-emitted, mark the callee as known-emitted.
-  // Otherwise, mark the call in our call graph so we can traverse it later.
-  bool CallerKnownEmitted = IsKnownEmitted(*this, Caller);
-  if (CallerKnownEmitted) {
-    // Host-side references to a __global__ function refer to the stub, so the
-    // function itself is never emitted and therefore should not be marked.
-    if (getLangOpts().CUDAIsDevice || IdentifyCUDATarget(Callee) != CFT_Global)
-      MarkKnownEmitted(*this, Caller, Callee, Loc);
-  } else {
-    // If we have
-    //   host fn calls kernel fn calls host+device,
-    // the HD function does not get instantiated on the host.  We model this by
-    // omitting at the call to the kernel from the callgraph.  This ensures
-    // that, when compiling for host, only HD functions actually called from the
-    // host get marked as known-emitted.
-    if (getLangOpts().CUDAIsDevice || IdentifyCUDATarget(Callee) != CFT_Global)
-      CUDACallGraph[Caller].insert({Callee, Loc});
-  }
-
-  CUDADiagBuilder::Kind DiagKind = [&] {
-    switch (IdentifyCUDAPreference(Caller, Callee)) {
-    case CFP_Never:
-      return CUDADiagBuilder::K_Immediate;
-    case CFP_WrongSide:
-      assert(Caller && "WrongSide calls require a non-null caller");
-      // If we know the caller will be emitted, we know this wrong-side call
-      // will be emitted, so it's an immediate error.  Otherwise, defer the
-      // error until we know the caller is emitted.
-      return CallerKnownEmitted ? CUDADiagBuilder::K_ImmediateWithCallStack
-                                : CUDADiagBuilder::K_Deferred;
-    default:
-      return CUDADiagBuilder::K_Nop;
-    }
-  }();
-
-  if (DiagKind == CUDADiagBuilder::K_Nop)
-    return true;
-
-  // Avoid emitting this error twice for the same location.  Using a hashtable
-  // like this is unfortunate, but because we must continue parsing as normal
-  // after encountering a deferred error, it's otherwise very tricky for us to
-  // ensure that we only emit this deferred error once.
-  if (!LocsWithCUDACallDiags.insert({Caller, Loc}).second)
-    return true;
-
-  CUDADiagBuilder(DiagKind, Loc, diag::err_ref_bad_target, Caller, *this)
-      << IdentifyCUDATarget(Callee) << Callee << IdentifyCUDATarget(Caller);
-  CUDADiagBuilder(DiagKind, Callee->getLocation(), diag::note_previous_decl,
-                  Caller, *this)
-      << Callee;
-  return DiagKind != CUDADiagBuilder::K_Immediate &&
-         DiagKind != CUDADiagBuilder::K_ImmediateWithCallStack;
-}
-
-void Sema::CUDASetLambdaAttrs(CXXMethodDecl *Method) {
-  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
-  if (Method->hasAttr<CUDAHostAttr>() || Method->hasAttr<CUDADeviceAttr>())
-    return;
-  FunctionDecl *CurFn = dyn_cast<FunctionDecl>(CurContext);
-  if (!CurFn)
-    return;
-  CUDAFunctionTarget Target = IdentifyCUDATarget(CurFn);
-  if (Target == CFT_Global || Target == CFT_Device) {
-    Method->addAttr(CUDADeviceAttr::CreateImplicit(Context));
-  } else if (Target == CFT_HostDevice) {
-    Method->addAttr(CUDADeviceAttr::CreateImplicit(Context));
-    Method->addAttr(CUDAHostAttr::CreateImplicit(Context));
-  }
-}
-
-void Sema::checkCUDATargetOverload(FunctionDecl *NewFD,
-                                   const LookupResult &Previous) {
-  assert(getLangOpts().CUDA && "Should only be called during CUDA compilation");
-  CUDAFunctionTarget NewTarget = IdentifyCUDATarget(NewFD);
-  for (NamedDecl *OldND : Previous) {
-    FunctionDecl *OldFD = OldND->getAsFunction();
-    if (!OldFD)
-      continue;
-
-    CUDAFunctionTarget OldTarget = IdentifyCUDATarget(OldFD);
-    // Don't allow HD and global functions to overload other functions with the
-    // same signature.  We allow overloading based on CUDA attributes so that
-    // functions can have different implementations on the host and device, but
-    // HD/global functions "exist" in some sense on both the host and device, so
-    // should have the same implementation on both sides.
-    if (NewTarget != OldTarget &&
-        ((NewTarget == CFT_HostDevice) || (OldTarget == CFT_HostDevice) ||
-         (NewTarget == CFT_Global) || (OldTarget == CFT_Global)) &&
-        !IsOverload(NewFD, OldFD, /* UseMemberUsingDeclRules = */ false,
-                    /* ConsiderCudaAttrs = */ false)) {
-      Diag(NewFD->getLocation(), diag::err_cuda_ovl_target)
-          << NewTarget << NewFD->getDeclName() << OldTarget << OldFD;
-      Diag(OldFD->getLocation(), diag::note_previous_declaration);
-      NewFD->setInvalidDecl();
-      break;
-    }
-  }
-}
-
-template <typename AttrTy>
-static void copyAttrIfPresent(Sema &S, FunctionDecl *FD,
-                              const FunctionDecl &TemplateFD) {
-  if (AttrTy *Attribute = TemplateFD.getAttr<AttrTy>()) {
-    AttrTy *Clone = Attribute->clone(S.Context);
-    Clone->setInherited(true);
-    FD->addAttr(Clone);
-  }
-}
-
-void Sema::inheritCUDATargetAttrs(FunctionDecl *FD,
-                                  const FunctionTemplateDecl &TD) {
-  const FunctionDecl &TemplateFD = *TD.getTemplatedDecl();
-  copyAttrIfPresent<CUDAGlobalAttr>(*this, FD, TemplateFD);
-  copyAttrIfPresent<CUDAHostAttr>(*this, FD, TemplateFD);
-  copyAttrIfPresent<CUDADeviceAttr>(*this, FD, TemplateFD);
-}