Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/SemaCUDA_8cpp_source.html below:

clang: lib/Sema/SemaCUDA.cpp Source File

;

(

*A =

->

<AttrT>())

!A->isImplicit();

assert(

().

&&

);

ForceHostDeviceDepth++;

assert(

().

&&

);

(ForceHostDeviceDepth == 0)

ForceHostDeviceDepth--;

(

(LLLLoc, diag::err_undeclared_var_use)

HasHostAttr =

;

HasDeviceAttr =

;

HasGlobalAttr =

;

HasInvalidTargetAttr =

;

(AL.getKind()) {

ParsedAttr::AT_CUDAGlobal:

HasGlobalAttr =

;

ParsedAttr::AT_CUDAHost:

ParsedAttr::AT_CUDADevice:

HasDeviceAttr =

;

ParsedAttr::AT_CUDAInvalidTarget:

HasInvalidTargetAttr =

;

(HasInvalidTargetAttr)

(HasHostAttr && HasDeviceAttr)

<

A>

return isa<A>(Attribute) &&

!(IgnoreImplicitAttr && Attribute->isImplicit());

*VD = dyn_cast_or_null<VarDecl>(

);

(VD && VD->hasGlobalStorage() && !VD->isStaticLocal()) {

((hasAttr<CUDADeviceAttr>(VD,

) &&

!hasAttr<CUDAHostAttr>(VD,

)) ||

hasAttr<CUDASharedAttr>(VD,

) ||

hasAttr<CUDAConstantAttr>(VD,

))

IgnoreImplicitHDAttr) {

(

->

<CUDAInvalidTargetAttr>())

(

->

<CUDAGlobalAttr>())

(hasAttr<CUDADeviceAttr>(

, IgnoreImplicitHDAttr)) {

(hasAttr<CUDAHostAttr>(

, IgnoreImplicitHDAttr))

}

(hasAttr<CUDAHostAttr>(

, IgnoreImplicitHDAttr)) {

}

((

->

() || !

->isUserProvided()) &&

!IgnoreImplicitHDAttr) {

(Var->

<HIPManagedAttr>())

Var->

<CUDAConstantAttr>() &&

!hasExplicitAttr<CUDAConstantAttr>(Var))

(Var->

<CUDADeviceAttr>() || Var->

<CUDAConstantAttr>() ||

Var->

<CUDASharedAttr>() ||

(

*FD = dyn_cast<FunctionDecl>(Var->

())) {

assert(Callee &&

);

(isa<CXXConstructorDecl>(Callee) || isa<CXXDestructorDecl>(Callee)))

(CalleeTarget == CallerTarget ||

llvm_unreachable(

);

(

*A =

->

<AttrT>())

A->isImplicit();

IsImplicitDevAttr = hasImplicitAttr<CUDADeviceAttr>(

);

IsImplicitHostAttr = hasImplicitAttr<CUDAHostAttr>(

);

IsImplicitDevAttr && IsImplicitHostAttr;

<std::pair<DeclAccessPair, FunctionDecl *>> &Matches) {

(Matches.size() <= 1)

Pair = std::pair<DeclAccessPair, FunctionDecl*>;

GetCFP = [&](

Pair &Match) {

Matches.begin(), Matches.end(),

[&](

Pair &M1,

Pair &M2) { return GetCFP(M1) < GetCFP(M2); }));

llvm::erase_if(Matches,

[&](

Pair &Match) {

GetCFP(Match) < BestCFP; });

*ResolvedTarget = Target2;

*ResolvedTarget = Target1;

}

(Target1 != Target2) {

*ResolvedTarget = Target1;

HasH = MemberDecl->

<CUDAHostAttr>();

HasD = MemberDecl->

<CUDADeviceAttr>();

HasExplicitAttr =

(HasD && !MemberDecl->

<CUDADeviceAttr>()->isImplicit()) ||

(HasH && !MemberDecl->

<CUDAHostAttr>()->isImplicit());

(!InClass || HasExplicitAttr)

std::optional<CUDAFunctionTarget> InferredTarget;

(

&B : ClassDecl->

()) {

(!B.isVirtual()) {

llvm::append_range(Bases, llvm::make_pointer_range(ClassDecl->

()));

(

*B : Bases) {

(!InferredTarget) {

InferredTarget = BaseMethodTarget;

*InferredTarget, BaseMethodTarget, &*InferredTarget);

(ResolutionError) {

diag::note_implicit_member_target_infer_collision)

<< (

)CSM << llvm::to_underlying(*InferredTarget)

<< llvm::to_underlying(BaseMethodTarget);

(

*F : ClassDecl->

()) {

(F->isInvalidDecl()) {

ConstRHS && !F->isMutable(),

(!InferredTarget) {

InferredTarget = FieldMethodTarget;

*InferredTarget, FieldMethodTarget, &*InferredTarget);

(ResolutionError) {

diag::note_implicit_member_target_infer_collision)

<< (

)CSM << llvm::to_underlying(*InferredTarget)

<< llvm::to_underlying(FieldMethodTarget);

NeedsH =

, NeedsD =

;

(InferredTarget) {

if (const CXXConstructExpr *CE =

dyn_cast<CXXConstructExpr>(CI->getInit()))

return isEmptyConstructor(Loc, CE->getConstructor());

if (CXXRecordDecl *RD = BS.getType()->getAsCXXRecordDecl())

return isEmptyDestructor(Loc, RD->getDestructor());

(!llvm::all_of(ClassDecl->

(), [&](

*Field) {

if (CXXRecordDecl *RD = Field->getType()

->getBaseElementTypeUnsafe()

->getAsCXXRecordDecl())

return isEmptyDestructor(Loc, RD->getDestructor());

CUDAInitializerCheckKind {

CICK_DeviceOrConstant,

IsDependentVar(

*VD) {

->isValueDependent();

CUDAInitializerCheckKind CheckKind) {

assert(!IsDependentVar(VD) &&

);

IsEmptyInit = [&](

*

) {

(

*CE = dyn_cast<CXXConstructExpr>(

)) {

S.isEmptyConstructor(VD->

(), CE->getConstructor());

IsConstantInit = [&](

*

) {

HasEmptyDtor = [&](

*VD) {

S.isEmptyDestructor(VD->

(), RD->getDestructor());

(CheckKind == CICK_Shared)

IsEmptyInit(

) && HasEmptyDtor(VD);

((IsEmptyInit(

) || IsConstantInit(

)) && HasEmptyDtor(VD));

IsSharedVar = VD->

<CUDASharedAttr>();

IsDeviceOrConstantVar =

(VD->

<CUDADeviceAttr>() || VD->

<CUDAConstantAttr>());

(IsDeviceOrConstantVar || IsSharedVar) {

(HasAllowedCUDADeviceStaticInitializer(

*

, VD, IsSharedVar ? CICK_Shared : CICK_DeviceOrConstant))

IsSharedVar ? diag::err_shared_var_init : diag::err_dynamic_var_init)

<<

->getSourceRange();

InitFn = CE->getConstructor();

}

(

*CE = dyn_cast<CallExpr>(

)) {

InitFn = CE->getDirectCallee();

(VD->

(), diag::err_ref_bad_target_global_initializer)

<< llvm::to_underlying(InitFnTarget) << InitFn;

!

().CUDAImplicitHostDeviceFunUsedByDevice.count(Caller))))

assert(

().

&&

);

(ForceHostDeviceDepth > 0) {

(!NewD->

<CUDAHostAttr>())

(!NewD->

<CUDADeviceAttr>())

(

().OffloadImplicitHostDeviceTemplates &&

!NewD->

<CUDAHostAttr>() && !NewD->

<CUDADeviceAttr>() &&

!NewD->

<CUDAGlobalAttr>() &&

NewD->

<CUDADeviceAttr>() || NewD->

<CUDAGlobalAttr>())

IsMatchingDeviceFn = [&](

*

) {

= Using->getTargetDecl();

OldD && OldD->

<CUDADeviceAttr>() &&

!OldD->

<CUDAHostAttr>() &&

It = llvm::find_if(

, IsMatchingDeviceFn);

diag::err_cuda_unattributed_constexpr_cannot_overload_device)

diag::note_cuda_conflicting_device_function_declared_here);

!VD->

<CUDASharedAttr>() &&

!IsDependentVar(VD) &&

HasAllowedCUDADeviceStaticInitializer(*

, VD,

CICK_DeviceOrConstant))) {

assert(

().

&&

);

SemaDiagnosticBuilder::Kind DiagKind = [&] {

SemaDiagnosticBuilder::K_Nop;

SemaDiagnosticBuilder::K_Immediate;

SemaDiagnosticBuilder::K_Nop;

SemaDiagnosticBuilder::K_Immediate;

? SemaDiagnosticBuilder::K_ImmediateWithCallStack

: SemaDiagnosticBuilder::K_Deferred;

SemaDiagnosticBuilder::K_Nop;

assert(

().

&&

);

SemaDiagnosticBuilder::Kind DiagKind = [&] {

SemaDiagnosticBuilder::K_Nop;

SemaDiagnosticBuilder::K_Immediate;

SemaDiagnosticBuilder::K_Nop;

SemaDiagnosticBuilder::K_Immediate;

? SemaDiagnosticBuilder::K_ImmediateWithCallStack

: SemaDiagnosticBuilder::K_Deferred;

SemaDiagnosticBuilder::K_Nop;

assert(

().

&&

);

assert(Callee &&

);

(ExprEvalCtx.isUnevaluated() || ExprEvalCtx.isConstantEvaluated())

SemaDiagnosticBuilder::Kind DiagKind = [

, Caller, Callee,

CallerKnownEmitted] {

assert(Caller &&

);

CallerKnownEmitted

? SemaDiagnosticBuilder::K_ImmediateWithCallStack

: SemaDiagnosticBuilder::K_Deferred;

SemaDiagnosticBuilder::K_Nop;

(DiagKind == SemaDiagnosticBuilder::K_Nop) {

Callee->hasAttr<CUDAGlobalAttr>() && !Callee->isDefined() &&

SemaDiagnosticBuilder(DiagKind,

, diag::err_ref_bad_target, Caller,

(!Callee->getBuiltinID())

SemaDiagnosticBuilder(DiagKind, Callee->getLocation(),

diag::note_previous_decl, Caller,

)

DiagKind != SemaDiagnosticBuilder::K_Immediate &&

DiagKind != SemaDiagnosticBuilder::K_ImmediateWithCallStack;

CalleeIsDevice = Callee->hasAttr<CUDADeviceAttr>();

!Caller->

<CUDAGlobalAttr>() && !Caller->

<CUDADeviceAttr>();

ShouldCheck = CalleeIsDevice && CallerIsHost;

DiagKind = SemaDiagnosticBuilder::K_Deferred;

diag::err_capture_bad_target, Callee,

)

diag::warn_maybe_capture_bad_target_this_ptr, Callee,

assert(

().

&&

);

(Method->

<CUDAHostAttr>() || Method->

<CUDADeviceAttr>())

assert(

().

&&

);

(NewTarget != OldTarget &&

!(

().OffloadImplicitHostDeviceTemplates &&

!(

().OffloadImplicitHostDeviceTemplates &&

<< llvm::to_underlying(NewTarget) << NewFD->

()

<< llvm::to_underlying(OldTarget) << OldFD;

(NewFD->

(), diag::warn_offload_incompatible_redeclare)

<< llvm::to_underlying(NewTarget) << llvm::to_underlying(OldTarget);

<

AttrTy>

(AttrTy *Attribute = TemplateFD.

<AttrTy>()) {

AttrTy *Clone = Attribute->clone(S.

);

Clone->setInherited(

);

copyAttrIfPresent<CUDAGlobalAttr>(

, FD, TemplateFD);

copyAttrIfPresent<CUDAHostAttr>(

, FD, TemplateFD);

copyAttrIfPresent<CUDADeviceAttr>(

, FD, TemplateFD);

;

().HIPUseNewLaunchAPI ?

:

;

;

;

Defines the clang::ASTContext interface.

static bool hasImplicitAttr(const ValueDecl *D)

Defines the clang::Expr interface and subclasses for C++ expressions.

llvm::MachO::Target Target

Defines the clang::Preprocessor interface.

static bool resolveCalleeCUDATargetConflict(CUDAFunctionTarget Target1, CUDAFunctionTarget Target2, CUDAFunctionTarget *ResolvedTarget)

When an implicitly-declared special member has to invoke more than one base/field special member,...

static bool hasAttr(const Decl *D, bool IgnoreImplicitAttr)

static void copyAttrIfPresent(Sema &S, FunctionDecl *FD, const FunctionDecl &TemplateFD)

static bool hasExplicitAttr(const VarDecl *D)

This file declares semantic analysis for CUDA constructs.

QualType getBaseElementType(const ArrayType *VAT) const

Return the innermost element type of an array type.

llvm::SetVector< const ValueDecl * > CUDAExternalDeviceDeclODRUsedByHost

Keep track of CUDA/HIP external kernels or device variables ODR-used by host code.

GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const

llvm::DenseSet< const FunctionDecl * > CUDAImplicitHostDeviceFunUsedByDevice

Keep track of CUDA/HIP implicit host device functions used on device side in device compilation.

FunctionDecl * getcudaConfigureCallDecl()

Attr - This represents one attribute.

Represents a base class of a C++ class.

Represents a call to a C++ constructor.

Represents a C++ constructor within a class.

Represents a C++ base or member initializer.

Represents a C++ destructor within a class.

Represents a static or instance method of a struct/union/class.

const CXXRecordDecl * getParent() const

Return the parent of this method declaration, which is the class in which this method is defined.

Represents a C++ struct/union/class.

base_class_range vbases()

bool isAbstract() const

Determine whether this class has a pure virtual function.

bool isDynamicClass() const

CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).

bool isDependentContext() const

Determines whether this context is dependent on a template parameter.

DeclContext * getLexicalParent()

getLexicalParent - Returns the containing lexical DeclContext.

A reference to a declared variable, function, enum, etc.

Decl - This represents one declaration (or definition), e.g.

bool isImplicit() const

isImplicit - Indicates whether the declaration was implicitly generated by the implementation.

void setInvalidDecl(bool Invalid=true)

setInvalidDecl - Indicates the Decl had a semantic error.

FunctionDecl * getAsFunction() LLVM_READONLY

Returns the function itself, or the templated function if this is a function template.

bool isInvalidDecl() const

SourceLocation getLocation() const

DeclContext * getDeclContext()

This represents one expression.

Represents a member of a struct/union/class.

Represents a function declaration or definition.

bool hasTrivialBody() const

Returns whether the function has a trivial body that does not require any specific codegen.

bool isFunctionTemplateSpecialization() const

Determine whether this function is a function template specialization.

FunctionTemplateDecl * getDescribedFunctionTemplate() const

Retrieves the function template that is described by this function declaration.

bool isTrivial() const

Whether this function is "trivial" in some specialized C++ senses.

bool isVariadic() const

Whether this function is variadic.

bool isTemplateInstantiation() const

Determines if the given function was instantiated from a function template.

bool isConstexpr() const

Whether this is a (C++11) constexpr function or constexpr constructor.

unsigned getNumParams() const

Return the number of parameters this function must have based on its FunctionType.

bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const

Returns true if the function has a definition that does not need to be instantiated.

Declaration of a template function.

FunctionDecl * getTemplatedDecl() const

Get the underlying function declaration of the template.

Represents the results of name lookup.

This represents a decl that may have a name.

DeclarationName getDeclName() const

Get the actual, stored name of the declaration, which may be a special name.

ParsedAttr - Represents a syntactic attribute.

A (possibly-)qualified type.

bool isConstQualified() const

Determine whether this type is const-qualified.

field_range fields() const

A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...

RecordDecl * getDecl() const

decl_type * getFirstDecl()

Return the first declaration of this declaration or itself if this is the only declaration.

Scope - A scope is a transient data structure that is used while parsing the program.

A generic diagnostic builder for errors which may or may not be deferred.

SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)

Emit a diagnostic.

ASTContext & getASTContext() const

const LangOptions & getLangOpts() const

DiagnosticsEngine & getDiagnostics() const

void PushForceHostDevice()

Increments our count of the number of times we've seen a pragma forcing functions to be host device.

void checkAllowedInitializer(VarDecl *VD)

void RecordImplicitHostDeviceFuncUsedByDevice(const FunctionDecl *FD)

Record FD if it is a CUDA/HIP implicit host device function used on device side in device compilation...

std::string getConfigureFuncName() const

Returns the name of the launch configuration function.

bool PopForceHostDevice()

Decrements our count of the number of times we've seen a pragma forcing functions to be host device.

CUDAFunctionTarget IdentifyTarget(const FunctionDecl *D, bool IgnoreImplicitHDAttr=false)

Determines whether the given function is a CUDA device/host/kernel/etc.

void maybeAddHostDeviceAttrs(FunctionDecl *FD, const LookupResult &Previous)

May add implicit CUDAHostAttr and CUDADeviceAttr attributes to FD, depending on FD and the current co...

ExprResult ActOnExecConfigExpr(Scope *S, SourceLocation LLLLoc, MultiExprArg ExecConfig, SourceLocation GGGLoc)

bool isEmptyConstructor(SourceLocation Loc, CXXConstructorDecl *CD)

bool isEmptyDestructor(SourceLocation Loc, CXXDestructorDecl *CD)

void checkTargetOverload(FunctionDecl *NewFD, const LookupResult &Previous)

Check whether NewFD is a valid overload for CUDA.

CUDAFunctionTarget CurrentTarget()

Gets the CUDA target for the current context.

SemaDiagnosticBuilder DiagIfHostCode(SourceLocation Loc, unsigned DiagID)

Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as host cod...

bool inferTargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, CXXSpecialMemberKind 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 ...

struct clang::SemaCUDA::CUDATargetContext CurCUDATargetCtx

CUDATargetContextKind

Defines kinds of CUDA global host/device context where a function may be called.

@ CTCK_InitGlobalVar

Unknown context.

SemaDiagnosticBuilder DiagIfDeviceCode(SourceLocation Loc, unsigned DiagID)

Creates a SemaDiagnosticBuilder that emits the diagnostic if the current context is "used as device c...

llvm::DenseSet< FunctionDeclAndLoc > LocsWithCUDACallDiags

FunctionDecls and SourceLocations for which CheckCall has emitted a (maybe deferred) "bad call" diagn...

bool CheckCall(SourceLocation Loc, FunctionDecl *Callee)

Check whether we're allowed to call Callee from the current context.

void inheritTargetAttrs(FunctionDecl *FD, const FunctionTemplateDecl &TD)

Copies target attributes from the template TD to the function FD.

static bool isImplicitHostDeviceFunction(const FunctionDecl *D)

void CheckLambdaCapture(CXXMethodDecl *D, const sema::Capture &Capture)

void MaybeAddConstantAttr(VarDecl *VD)

May add implicit CUDAConstantAttr attribute to VD, depending on VD and current compilation settings.

void EraseUnwantedMatches(const FunctionDecl *Caller, llvm::SmallVectorImpl< std::pair< DeclAccessPair, FunctionDecl * > > &Matches)

Finds a function in Matches with highest calling priority from Caller context and erases all function...

void SetLambdaAttrs(CXXMethodDecl *Method)

Set device or host device attributes on the given lambda operator() method.

CUDAFunctionPreference IdentifyPreference(const FunctionDecl *Caller, const FunctionDecl *Callee)

Identifies relative preference of a given Caller/Callee combination, based on their host/device attri...

@ CVT_Host

Emitted on device side with a shadow variable on host side.

@ CVT_Both

Emitted on host side only.

@ CVT_Unified

Emitted on both sides with different addresses.

SpecialMemberOverloadResult - The overloading result for a special member function.

CXXMethodDecl * getMethod() const

Sema - This implements semantic analysis and AST building for C.

bool IsOverload(FunctionDecl *New, FunctionDecl *Old, bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs=true)

bool IsLastErrorImmediate

Is the last error level diagnostic immediate.

const ExpressionEvaluationContextRecord & currentEvaluationContext() const

FunctionDecl * getCurFunctionDecl(bool AllowLambda=false) const

Returns a pointer to the innermost enclosing function, or nullptr if the current context is not insid...

ASTContext & getASTContext() const

const LangOptions & getLangOpts() const

ExprResult BuildCallExpr(Scope *S, Expr *Fn, SourceLocation LParenLoc, MultiExprArg ArgExprs, SourceLocation RParenLoc, Expr *ExecConfig=nullptr, bool IsExecConfig=false, bool AllowRecovery=false)

BuildCallExpr - Handle a call to Fn with the specified array of arguments.

FunctionEmissionStatus getEmissionStatus(const FunctionDecl *Decl, bool Final=false)

SourceManager & getSourceManager() const

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.

SpecialMemberOverloadResult LookupSpecialMember(CXXRecordDecl *D, CXXSpecialMemberKind SM, bool ConstArg, bool VolatileArg, bool RValueThis, bool ConstThis, bool VolatileThis)

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,...

Encodes a location in the source.

bool isInSystemHeader(SourceLocation Loc) const

Returns if a SourceLocation is in a system header.

CXXRecordDecl * getAsCXXRecordDecl() const

Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...

bool isReferenceType() const

bool isCUDADeviceBuiltinSurfaceType() const

Check if the type is the CUDA device builtin surface type.

bool isDependentType() const

Whether this type is a dependent type, meaning that its definition somehow depends on a template para...

bool isCUDADeviceBuiltinTextureType() const

Check if the type is the CUDA device builtin texture type.

const T * getAs() const

Member-template getAs<specific type>'.

Represents a shadow declaration implicitly introduced into a scope by a (resolved) using-declaration ...

Represents a variable declaration or definition.

bool isConstexpr() const

Whether this variable is (C++11) constexpr.

bool isStaticDataMember() const

Determines whether this is a static data member.

bool hasGlobalStorage() const

Returns true for all variables that do not have local storage.

bool isFileVarDecl() const

Returns true for file scoped variable declaration.

const Expr * getInit() const

ValueDecl * getVariable() const

bool isVariableCapture() const

SourceLocation getLocation() const

Retrieve the location at which this variable was captured.

bool isThisCapture() const

bool isReferenceCapture() const

Defines the clang::TargetInfo interface.

The JSON file list parser is used to communicate input to InstallAPI.

bool CudaFeatureEnabled(llvm::VersionTuple, CudaFeature)

CXXSpecialMemberKind

Kinds of C++ special members.

@ VK_LValue

An l-value expression is a reference to an object with independent storage.

CUDATargetContextKind Kind

CUDAFunctionTarget Target

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4