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

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

clang: lib/Sema/SemaHLSL.cpp Source File

;

ResourceClass::SRV:

RegisterType::SRV;

ResourceClass::UAV:

RegisterType::UAV;

ResourceClass::CBuffer:

RegisterType::CBuffer;

ResourceClass::Sampler:

RegisterType::Sampler;

llvm_unreachable(

);

assert(RT !=

);

*RT = RegisterType::SRV;

*RT = RegisterType::UAV;

*RT = RegisterType::CBuffer;

*RT = RegisterType::Sampler;

*RT = RegisterType::C;

*RT = RegisterType::I;

RegisterType::SRV:

ResourceClass::SRV;

RegisterType::UAV:

ResourceClass::UAV;

RegisterType::CBuffer:

ResourceClass::CBuffer;

RegisterType::Sampler:

ResourceClass::Sampler;

RegisterType::C:

RegisterType::I:

llvm_unreachable(

);

ResourceClass ResClass) {

);

DeclToBindingListIndex.try_emplace(VD, BindingsList.size());

&BindingsList.emplace_back(VD, ResClass);

ResourceClass ResClass) {

Entry = DeclToBindingListIndex.find(VD);

(Entry != DeclToBindingListIndex.end()) {

(

Index = Entry->getSecond();

Index < BindingsList.size() && BindingsList[Index].Decl == VD;

(BindingsList[Index].ResClass == ResClass)

&BindingsList[Index];

DeclToBindingListIndex.contains(VD);

(), LexicalParent, CBuffer, KwLoc, Ident, IdentLoc, LBrace);

RC = CBuffer ? llvm::hlsl::ResourceClass::CBuffer

: llvm::hlsl::ResourceClass::SRV;

RK = CBuffer ? llvm::hlsl::ResourceKind::CBuffer

: llvm::hlsl::ResourceKind::TBuffer;

CBufferAlign = 16;

FieldAlign = 4;

FieldAlign = CBufferAlign;

Size = llvm::alignTo(Size, FieldAlign);

(

ElementCount = AT->getSize().getZExtValue()) {

ElementSize =

AlignedElementSize = llvm::alignTo(ElementSize, CBufferAlign);

Size = AlignedElementSize * (ElementCount - 1) + ElementSize;

ElementCount = VT->getNumElements();

ElementSize =

Size = ElementSize * ElementCount;

HasPackOffset =

;

HasNonPackOffset =

;

(

*Field : BufDecl->

()) {

*Var = dyn_cast<VarDecl>(Field);

(Field->hasAttr<HLSLPackOffsetAttr>()) {

PackOffsetVec.emplace_back(Var, Field->getAttr<HLSLPackOffsetAttr>());

HasPackOffset =

;

HasNonPackOffset =

;

(HasNonPackOffset)

std::sort(PackOffsetVec.begin(), PackOffsetVec.end(),

[](

std::pair<VarDecl *, HLSLPackOffsetAttr *> &LHS,

std::pair<VarDecl *, HLSLPackOffsetAttr *> &RHS) {

return LHS.second->getOffsetInBytes() <

RHS.second->getOffsetInBytes();

(

i = 0; i < PackOffsetVec.size() - 1; i++) {

*Var = PackOffsetVec[i].first;

HLSLPackOffsetAttr *

= PackOffsetVec[i].second;

=

->getOffsetInBytes();

End =

+ Size;

NextBegin = PackOffsetVec[i + 1].second->getOffsetInBytes();

(End > NextBegin) {

*NextVar = PackOffsetVec[i + 1].first;

CAT = dyn_cast<ConstantArrayType>(

CAT !=

;

.getType()->getAsCXXRecordDecl()))

assert(RD ==

&&

);

Name.append(NameBaseII->

());

Name.append(

);

MustBeUnique =

;

NameLength = Name.size();

Name.append(llvm::Twine(suffix).str());

II = &AST.

.

(Name, tok::TokenKind::identifier);

Name.truncate(NameLength);

);

(

NumBases = StructDecl->

()) {

assert(NumBases == 1 &&

);

*VD = dyn_cast<VarDecl>(

);

*BufDecl = cast<HLSLBufferDecl>(Dcl);

BufDecl->setRBraceLoc(RBrace);

,

Y,

Z) {

(HLSLNumThreadsAttr *NT =

->

<HLSLNumThreadsAttr>()) {

(NT->getX() !=

|| NT->getY() != Y || NT->getZ() != Z) {

(NT->getLocation(), diag::err_hlsl_attribute_param_mismatch) << AL;

(AL.

(), diag::note_conflicting_attribute);

,

,

Preferred,

SpelledArgsCount) {

(HLSLWaveSizeAttr *WS =

->

<HLSLWaveSizeAttr>()) {

(WS->getMin() !=

|| WS->getMax() !=

||

WS->getPreferred() != Preferred ||

WS->getSpelledArgsCount() != SpelledArgsCount) {

(WS->getLocation(), diag::err_hlsl_attribute_param_mismatch) << AL;

(AL.

(), diag::note_conflicting_attribute);

->setSpelledArgsCount(SpelledArgsCount);

llvm::Triple::EnvironmentType ShaderType) {

(HLSLShaderAttr *NT =

->

<HLSLShaderAttr>()) {

(NT->getType() != ShaderType) {

(NT->getLocation(), diag::err_hlsl_attribute_param_mismatch) << AL;

(AL.

(), diag::note_conflicting_attribute);

HLSLShaderAttr::Create(

(), ShaderType, AL);

HLSLParamModifierAttr *

HLSLParamModifierAttr::Spelling Spelling) {

(HLSLParamModifierAttr *PA =

->

<HLSLParamModifierAttr>()) {

((PA->isIn() && Spelling == HLSLParamModifierAttr::Keyword_out) ||

(PA->isOut() && Spelling == HLSLParamModifierAttr::Keyword_in)) {

HLSLParamModifierAttr::Create(

HLSLParamModifierAttr::Keyword_inout);

(AL.

(), diag::err_hlsl_duplicate_parameter_modifier) << AL;

(PA->getLocation(), diag::note_conflicting_attribute);

(HLSLShaderAttr::isValidShaderType(

) &&

!= llvm::Triple::Library) {

(

*Shader = FD->

<HLSLShaderAttr>()) {

(Shader->getType() !=

) {

(Shader->getLocation(), diag::err_hlsl_entry_shader_attr_mismatch)

llvm::Triple::UnknownEnvironment:

llvm::Triple::Library:

llvm_unreachable(

);

*ShaderAttr = FD->

<HLSLShaderAttr>();

assert(ShaderAttr &&

);

llvm::Triple::EnvironmentType ST = ShaderAttr->getType();

llvm::Triple::Pixel:

llvm::Triple::Vertex:

llvm::Triple::Geometry:

llvm::Triple::Hull:

llvm::Triple::Domain:

llvm::Triple::RayGeneration:

llvm::Triple::Intersection:

llvm::Triple::AnyHit:

llvm::Triple::ClosestHit:

llvm::Triple::Miss:

llvm::Triple::Callable:

(

*NT = FD->

<HLSLNumThreadsAttr>()) {

{llvm::Triple::Compute,

llvm::Triple::Amplification,

llvm::Triple::Mesh});

(

*WS = FD->

<HLSLWaveSizeAttr>()) {

{llvm::Triple::Compute,

llvm::Triple::Amplification,

llvm::Triple::Mesh});

llvm::Triple::Compute:

llvm::Triple::Amplification:

llvm::Triple::Mesh:

(!FD->

<HLSLNumThreadsAttr>()) {

<< llvm::Triple::getEnvironmentTypeName(ST);

(

*WS = FD->

<HLSLWaveSizeAttr>()) {

(Ver < VersionTuple(6, 6)) {

(WS->getLocation(), diag::err_hlsl_attribute_in_wrong_shader_model)

}

(WS->getSpelledArgsCount() > 1 && Ver < VersionTuple(6, 8)) {

diag::err_hlsl_attribute_number_arguments_insufficient_shader_model)

<< WS << WS->getSpelledArgsCount() <<

;

llvm_unreachable(

);

(FD->

(), diag::err_hlsl_missing_semantic_annotation);

(Param->getLocation(), diag::note_previous_decl) << Param;

*ShaderAttr = EntryPoint->

<HLSLShaderAttr>();

assert(ShaderAttr &&

);

llvm::Triple::EnvironmentType ST = ShaderAttr->getType();

(AnnotationAttr->

()) {

attr::HLSLSV_DispatchThreadID:

attr::HLSLSV_GroupIndex:

attr::HLSLSV_GroupThreadID:

attr::HLSLSV_GroupID:

(ST == llvm::Triple::Compute)

llvm_unreachable(

);

*A, llvm::Triple::EnvironmentType Stage,

std::initializer_list<llvm::Triple::EnvironmentType> AllowedStages) {

llvm::transform(AllowedStages, std::back_inserter(StageStrings),

[](llvm::Triple::EnvironmentType ST) {

HLSLShaderAttr::ConvertEnvironmentTypeToStr(ST));

(A->

(), diag::err_hlsl_attr_unsupported_in_stage)

<< A << llvm::Triple::getEnvironmentTypeName(Stage)

<< (AllowedStages.size() != 1) << join(StageStrings,

);

<CastKind Kind>

Ty = VTy->getElementType();

<CastKind Kind>

(LHSFloat && RHSFloat) {

castElement<CK_FloatingCast>(SemaRef, RHS, LHSType);

castElement<CK_FloatingCast>(SemaRef, LHS, RHSType);

castElement<CK_IntegralToFloating>(SemaRef, RHS, LHSType);

castElement<clang::CK_FloatingToIntegral>(SemaRef, RHS, LHSType);

castElement<CK_IntegralToFloating>(SemaRef, LHS, RHSType);

(LHSSigned == RHSSigned) {

(IsCompAssign || IntOrder >= 0)

castElement<CK_IntegralCast>(SemaRef, RHS, LHSType);

castElement<CK_IntegralCast>(SemaRef, LHS, RHSType);

(IntOrder != (LHSSigned ? 1 : -1)) {

(IsCompAssign || RHSSigned)

castElement<CK_IntegralCast>(SemaRef, RHS, LHSType);

castElement<CK_IntegralCast>(SemaRef, LHS, RHSType);

(IsCompAssign || LHSSigned)

castElement<CK_IntegralCast>(SemaRef, RHS, LHSType);

castElement<CK_IntegralCast>(SemaRef, LHS, RHSType);

castElement<CK_IntegralCast>(SemaRef, RHS, LHSType);

(void)castElement<CK_IntegralCast>(SemaRef, RHS, NewTy);

castElement<CK_IntegralCast>(SemaRef, LHS, NewTy);

CK_FloatingCast;

CK_IntegralCast;

CK_IntegralToFloating;

CK_FloatingToIntegral;

(!LVecTy && IsCompAssign) {

EndSz = std::numeric_limits<unsigned>::max();

LSz = EndSz = LVecTy->getNumElements();

assert(EndSz != std::numeric_limits<unsigned>::max() &&

);

(IsCompAssign && LSz != EndSz) {

diag::err_hlsl_vector_compound_assignment_truncation)

<< LHSType << RHSType;

castVector<CK_HLSLVectorTruncation>(

, RHS, RHSType, EndSz);

(!IsCompAssign && LVecTy && LVecTy->getNumElements() > EndSz)

castVector<CK_HLSLVectorTruncation>(

, LHS, LHSType, EndSz);

castVector<CK_VectorSplat>(

, RHS, RHSType, EndSz);

(!IsCompAssign && !LVecTy)

castVector<CK_VectorSplat>(

, LHS, LHSType, EndSz);

LElTy, RElTy, IsCompAssign);

);

LElTy, RElTy, IsCompAssign);

assert((Opc == BO_LOr || Opc == BO_LAnd) &&

);

llvm::raw_svector_ostream OS(Buff);

StringRef NewFnName = Opc == BO_LOr ?

:

;

OS << NewFnName <<

;

llvm::VersionTuple SMVersion =

uint32_t ZMax = 1024;

uint32_t ThreadMax = 1024;

(SMVersion.getMajor() <= 4) {

}

(SMVersion.getMajor() == 5) {

diag::err_hlsl_numthreads_argument_oor)

diag::err_hlsl_numthreads_argument_oor)

diag::err_hlsl_numthreads_argument_oor)

(

* Y * Z > ThreadMax) {

(AL.

(), diag::err_hlsl_numthreads_invalid) << ThreadMax;

SpelledArgsCount = AL.

();

(SpelledArgsCount == 0 || SpelledArgsCount > 3)

(SpelledArgsCount > 1 &&

uint32_t Preferred = 0;

(SpelledArgsCount > 2 &&

(SpelledArgsCount > 2) {

diag::err_attribute_power_of_two_in_range)

<< AL << llvm::dxil::MinWaveSize << llvm::dxil::MaxWaveSize

(Preferred < Min || Preferred >

) {

diag::err_attribute_power_of_two_in_range)

<< AL <<

<<

<< Preferred;

}

(SpelledArgsCount > 1) {

diag::err_attribute_power_of_two_in_range)

<< AL << llvm::dxil::MinWaveSize << llvm::dxil::MaxWaveSize <<

;

(AL.

(), diag::err_attribute_argument_invalid) << AL << 1;

}

(

==

) {

(AL.

(), diag::warn_attr_min_eq_max) << AL;

diag::err_attribute_power_of_two_in_range)

<< AL << llvm::dxil::MinWaveSize << llvm::dxil::MaxWaveSize <<

;

HLSLWaveSizeAttr *NewAttr =

(VT && VT->getNumElements() > 3)) {

(AL.

(), diag::err_hlsl_attr_invalid_type)

<< AL <<

;

*VD = cast<ValueDecl>(

);

*VD = cast<ValueDecl>(

);

*VD = cast<ValueDecl>(

);

(AL.

(), diag::err_hlsl_attr_invalid_ast_node)

<< AL <<

;

uint32_t SubComponent;

= cast<VarDecl>(

)->getType().getCanonicalType();

(IsAggregateTy || Size > 128) {

(AL.

(), diag::err_hlsl_packoffset_cross_reg_boundary);

((Component * 32 + Size) > 128) {

(AL.

(), diag::err_hlsl_packoffset_cross_reg_boundary);

EltTy = VT->getElementType();

(Align > 32 && Component == 1) {

(AL.

(), diag::err_hlsl_packoffset_alignment_mismatch)

llvm::Triple::EnvironmentType ShaderType;

(!HLSLShaderAttr::ConvertStrToEnvironmentType(Str, ShaderType)) {

(AL.

(), diag::warn_attribute_type_not_supported)

<< AL << Str << ArgLoc;

assert(AttrList.size() &&

);

HasResourceClass =

;

(

*A : AttrList) {

LocEnd = A->getRange().getEnd();

(A->getKind()) {

attr::HLSLResourceClass: {

ResourceClass RC = cast<HLSLResourceClassAttr>(A)->getResourceClass();

(HasResourceClass) {

? diag::warn_duplicate_attribute_exact

: diag::warn_duplicate_attribute)

HasResourceClass =

;

(ResAttrs.

) {

S.

(A->getLocation(), diag::warn_duplicate_attribute_exact) << A;

ResAttrs.

=

;

attr::HLSLRawBuffer:

S.

(A->getLocation(), diag::warn_duplicate_attribute_exact) << A;

attr::HLSLContainedType: {

HLSLContainedTypeAttr *CTAttr = cast<HLSLContainedTypeAttr>(A);

(!ContainedTy.

()) {

S.

(A->getLocation(), ContainedTy == Ty

? diag::warn_duplicate_attribute_exact

: diag::warn_duplicate_attribute)

llvm_unreachable(

);

(!HasResourceClass) {

S.

(AttrList.back()->getRange().getEnd(),

diag::err_hlsl_missing_resource_class);

Wrapped, ContainedTy, ResAttrs);

(LocInfo && ContainedTyInfo) {

(!

->isHLSLResourceType()) {

(AL.

(), diag::err_hlsl_attribute_needs_intangible_type)

ParsedAttr::AT_HLSLResourceClass: {

(AL.

(), diag::err_attribute_argument_type)

(!HLSLResourceClassAttr::ConvertStrToResourceClass(

, RC)) {

(ArgLoc, diag::warn_attribute_type_not_supported)

ParsedAttr::AT_HLSLROV:

ParsedAttr::AT_HLSLRawBuffer:

ParsedAttr::AT_HLSLContainedType: {

(AL.

(), diag::err_attribute_wrong_number_arguments) << AL << 1;

assert(TSI &&

);

diag::err_incomplete_type))

llvm_unreachable(

);

HLSLResourcesTypeAttrs.emplace_back(A);

(!HLSLResourcesTypeAttrs.size())

HLSLResourcesTypeAttrs, QT, &LocInfo)) {

cast<HLSLAttributedResourceType>(QT.

());

LocsForHLSLAttributedResources.insert(std::pair(RT, LocInfo));

HLSLResourcesTypeAttrs.clear();

I = LocsForHLSLAttributedResources.find(RT);

(I != LocsForHLSLAttributedResources.end()) {

LocInfo = I->second;

LocsForHLSLAttributedResources.erase(I);

SemaHLSL::collectResourcesOnUserRecordDecl(

*VD,

);

ResourceClass RC = AttrResType->getAttrs().ResourceClass;

.addDeclBindingInfo(VD, RC);

}

(

*RT = dyn_cast<RecordType>(Ty)) {

collectResourcesOnUserRecordDecl(VD, RT);

SpecifiedSpace) {

RegTypeNum =

(RegType);

(

->

<HLSLGroupSharedAddressSpaceAttr>()) {

S.

(ArgLoc, diag::err_hlsl_binding_type_mismatch) << RegTypeNum;

(

*CBufferOrTBuffer = dyn_cast<HLSLBufferDecl>(

)) {

ResourceClass RC = CBufferOrTBuffer->isCBuffer() ? ResourceClass::CBuffer

: ResourceClass::SRV;

assert(isa<VarDecl>(

) &&

);

(RegType ==

(AttrResType->getAttrs().ResourceClass))

DeclaredInCOrTBuffer = isa<HLSLBufferDecl>(

->

());

(SpecifiedSpace && !DeclaredInCOrTBuffer)

S.

(ArgLoc, diag::err_hlsl_space_on_global_constant);

(!DeclaredInCOrTBuffer &&

(RegType == RegisterType::CBuffer)

S.

(ArgLoc, diag::warn_hlsl_deprecated_register_type_b);

(RegType != RegisterType::C)

S.

(ArgLoc, diag::err_hlsl_binding_type_mismatch) << RegTypeNum;

(RegType == RegisterType::C)

S.

(ArgLoc, diag::warn_hlsl_register_type_c_packoffset);

S.

(ArgLoc, diag::err_hlsl_binding_type_mismatch) << RegTypeNum;

S.

(ArgLoc, diag::err_hlsl_binding_type_mismatch) << RegTypeNum;

RegisterTypesDetected[5] = {

};

RegisterTypesDetected[

(regType)] =

;

(HLSLResourceBindingAttr *

=

dyn_cast<HLSLResourceBindingAttr>(*it)) {

(RegisterTypesDetected[

(otherRegType)]) {

otherRegTypeNum =

(otherRegType);

diag::err_hlsl_duplicate_register_annotation)

RegisterTypesDetected[

(otherRegType)] =

;

SpecifiedSpace) {

assert(((isa<VarDecl>(

) && !isa<HLSLBufferDecl>(

)) ||

(!isa<VarDecl>(

) && isa<HLSLBufferDecl>(

))) &&

);

(isa<VarDecl>(TheDecl)) {

cast<ValueDecl>(TheDecl)->getType(),

diag::err_incomplete_type))

StringRef Space =

;

StringRef Slot =

;

(AL.

(), diag::err_attribute_argument_type)

StringRef Str =

->Ident->getName();

SpecifiedSpace =

;

SpecifiedSpace =

;

(AL.

(), diag::err_attribute_argument_type)

Space =

->Ident->getName();

SpaceArgLoc =

->Loc;

SlotNum = 0;

SpaceNum = 0;

(!Slot.empty()) {

(ArgLoc, diag::err_hlsl_binding_type_invalid) << Slot.substr(0, 1);

(RegType == RegisterType::I) {

(ArgLoc, diag::warn_hlsl_deprecated_register_type_i);

StringRef SlotNumStr = Slot.substr(1);

(SlotNumStr.getAsInteger(10, SlotNum)) {

(ArgLoc, diag::err_hlsl_unsupported_register_number);

(!Space.starts_with(

)) {

(SpaceArgLoc, diag::err_hlsl_expected_space) << Space;

StringRef SpaceNumStr = Space.substr(5);

(SpaceNumStr.getAsInteger(10, SpaceNum)) {

(SpaceArgLoc, diag::err_hlsl_expected_space) << Space;

HLSLResourceBindingAttr *NewAttr =

HLSLResourceBindingAttr::Create(

(), Slot, Space, AL);

NewAttr->setBinding(RegType, SlotNum, SpaceNum);

llvm::DenseMap<const FunctionDecl *, unsigned> ScannedDecls;

llvm::Triple::EnvironmentType CurrentShaderEnvironment;

CurrentShaderStageBit;

ReportOnlyShaderStageIssues;

SetShaderStageContext(llvm::Triple::EnvironmentType ShaderType) {

(

(

) >= 4);

assert(HLSLShaderAttr::isValidShaderType(ShaderType));

assert((

)(ShaderType - llvm::Triple::Pixel) < 31 &&

);

bitmapIndex = ShaderType - llvm::Triple::Pixel;

CurrentShaderEnvironment = ShaderType;

CurrentShaderStageBit = (1 << bitmapIndex);

SetUnknownShaderStageContext() {

CurrentShaderEnvironment = llvm::Triple::UnknownEnvironment;

CurrentShaderStageBit = (1 << 31);

llvm::Triple::EnvironmentType GetCurrentShaderEnvironment()

{

CurrentShaderEnvironment;

InUnknownShaderStageContext()

{

CurrentShaderEnvironment == llvm::Triple::UnknownEnvironment;

&ScannedStages = ScannedDecls[FD];

ScannedStages |= CurrentShaderStageBit;

GetScannedStages(

*FD) {

ScannedDecls[FD]; }

WasAlreadyScannedInCurrentStage(

*FD) {

WasAlreadyScannedInCurrentStage(GetScannedStages(FD));

WasAlreadyScannedInCurrentStage(

ScannerStages) {

ScannerStages & CurrentShaderStageBit;

NeverBeenScanned(

ScannedStages) {

ScannedStages == 0;

CheckDeclAvailability(

*

,

AvailabilityAttr *AA,

AvailabilityAttr *FindAvailabilityAttr(

*

);

HasMatchingEnvironmentOrNone(

AvailabilityAttr *AA);

DiagnoseHLSLAvailability(

&SemaRef)

CurrentShaderEnvironment(

::Triple::UnknownEnvironment),

CurrentShaderStageBit(0), ReportOnlyShaderStageIssues(

) {}

VisitDeclRefExpr(

*DRE)

{

HandleFunctionOrMethodRef(FD, DRE);

VisitMemberExpr(

*ME)

{

HandleFunctionOrMethodRef(FD, ME);

DiagnoseHLSLAvailability::HandleFunctionOrMethodRef(

*FD,

assert((isa<DeclRefExpr>(RefExpr) || isa<MemberExpr>(RefExpr)) &&

);

(FD->

(FDWithBody)) {

(!WasAlreadyScannedInCurrentStage(FDWithBody))

DeclsToScan.push_back(FDWithBody);

AvailabilityAttr *AA = FindAvailabilityAttr(FD);

CheckDeclAvailability(

DiagnoseHLSLAvailability::RunOnTranslationUnit(

DeclContextsToScan.push_back(TU);

(!DeclContextsToScan.empty()) {

*DC = DeclContextsToScan.pop_back_val();

(

&

: DC->

()) {

(llvm::dyn_cast<NamespaceDecl>(

) || llvm::dyn_cast<ExportDecl>(

)) {

DeclContextsToScan.push_back(llvm::dyn_cast<DeclContext>(

));

(HLSLShaderAttr *ShaderAttr = FD->

<HLSLShaderAttr>()) {

SetShaderStageContext(ShaderAttr->getType());

(

*Redecl : FD->

()) {

(Redecl->isInExportDeclContext()) {

SetUnknownShaderStageContext();

DiagnoseHLSLAvailability::RunOnFunction(

*FD) {

assert(DeclsToScan.empty() &&

);

DeclsToScan.push_back(FD);

(!DeclsToScan.empty()) {

ScannedStages = GetScannedStages(FD);

(WasAlreadyScannedInCurrentStage(ScannedStages))

ReportOnlyShaderStageIssues = !NeverBeenScanned(ScannedStages);

AddToScannedFunctions(FD);

TraverseStmt(FD->

());

DiagnoseHLSLAvailability::HasMatchingEnvironmentOrNone(

AvailabilityAttr *AA) {

llvm::Triple::EnvironmentType CurrentEnv = GetCurrentShaderEnvironment();

(CurrentEnv == llvm::Triple::UnknownEnvironment)

llvm::Triple::EnvironmentType AttrEnv =

AvailabilityAttr::getEnvironmentType(IIEnvironment->

());

CurrentEnv == AttrEnv;

AvailabilityAttr *

DiagnoseHLSLAvailability::FindAvailabilityAttr(

*

) {

AvailabilityAttr

*PartialMatch =

;

(

*A :

->

()) {

(

*Avail = dyn_cast<AvailabilityAttr>(A)) {

StringRef AttrPlatform = Avail->getPlatform()->getName();

StringRef TargetPlatform =

(AttrPlatform == TargetPlatform) {

(HasMatchingEnvironmentOrNone(Avail))

PartialMatch = Avail;

PartialMatch;

DiagnoseHLSLAvailability::CheckDeclAvailability(

*

,

AvailabilityAttr *AA,

(SemaRef.

().HLSLStrictAvailability)

(ReportOnlyShaderStageIssues)

(InUnknownShaderStageContext())

EnvironmentMatches = HasMatchingEnvironmentOrNone(AA);

VersionTuple Introduced = AA->getIntroduced();

llvm::StringRef PlatformName(

llvm::StringRef CurrentEnvStr =

llvm::Triple::getEnvironmentTypeName(GetCurrentShaderEnvironment());

llvm::StringRef AttrEnvStr =

AA->getEnvironment() ? AA->getEnvironment()->getName() :

;

UseEnvironment = !AttrEnvStr.empty();

(EnvironmentMatches) {

<<

<<

<< PlatformName << Introduced.getAsString()

<< UseEnvironment << CurrentEnvStr;

SemaRef.

(

->

(), diag::note_partial_availability_specified_here)

<<

<< PlatformName << Introduced.getAsString()

<< UseEnvironment << AttrEnvStr << CurrentEnvStr;

TI.

().getEnvironment() != llvm::Triple::EnvironmentType::Library)

DiagnoseHLSLAvailability(

).RunOnTranslationUnit(TU);

AllBArgAreVectors =

;

(

i = 1; i < TheCall->

(); ++i) {

(VecTyB ==

)

AllBArgAreVectors &=

;

(VecTyA && VecTyB ==

) {

S->

(BuiltinLoc, diag::err_vec_builtin_non_vector)

(VecTyA && VecTyB) {

retValue =

;

(VecTyA->getElementType() != VecTyB->getElementType()) {

diag::err_vec_builtin_incompatible_vector)

(VecTyA->getNumElements() != VecTyB->getNumElements()) {

S->

(BuiltinLoc, diag::err_vec_builtin_incompatible_vector)

(VecTyA ==

&& AllBArgAreVectors) {

S->

(BuiltinLoc, diag::err_vec_builtin_non_vector)

S->

(Arg->

(), diag::err_typecheck_convert_incompatible)

(Check(PassedType)) {

, VecTyA->getNumElements(), VecTyA->getVectorKind());

S->

(Arg->

(), diag::err_typecheck_convert_incompatible)

(

i = 0; i < TheCall->

(); ++i) {

!PassedType->hasFloatingRepresentation();

checkAllFloatTypes);

ArgIndex) {

*Arg = TheCall->

(ArgIndex);

S->

(OrigLoc, diag::error_hlsl_inout_lvalue) << Arg << 0;

(

*VecTy = PassedType->getAs<

>())

VecTy->getElementType()->isDoubleType();

!PassedType->hasIntegerRepresentation() &&

!PassedType->hasFloatingRepresentation();

checkAllSignedTypes);

checkAllUnsignedTypes = [](

PassedType) ->

{

!PassedType->hasUnsignedIntegerRepresentation();

checkAllUnsignedTypes);

TheCall->

(ReturnType);

ArgIndex) {

diag::err_typecheck_expect_scalar_or_vector)

<< ArgType << Scalar;

ArgIndex) {

(VTy && VTy->getElementType()->isScalarType()))) {

diag::err_typecheck_expect_any_scalar_or_vector)

diag::err_typecheck_expect_any_scalar_or_vector)

diag::err_typecheck_call_different_arg_types)

diag::err_typecheck_call_different_arg_types)

diag::err_typecheck_vector_lengths_not_equal)

diag::err_typecheck_expect_hlsl_resource)

(Check && Check(ResTy)) {

diag::err_invalid_hlsl_resource_type)

(BuiltinID) {

Builtin::BI__builtin_hlsl_resource_getpointer: {

ContainedTy = ResourceTy->getContainedType();

Builtin::BI__builtin_hlsl_all:

Builtin::BI__builtin_hlsl_any: {

Builtin::BI__builtin_hlsl_asdouble: {

Builtin::BI__builtin_hlsl_elementwise_clamp: {

Builtin::BI__builtin_hlsl_cross: {

NumElementsArg1 =

NumElementsArg2 =

(NumElementsArg1 != 3) {

LessOrMore = NumElementsArg1 > 3 ? 1 : 0;

diag::err_vector_incorrect_num_elements)

<< LessOrMore << 3 << NumElementsArg1 <<

1;

(NumElementsArg2 != 3) {

LessOrMore = NumElementsArg2 > 3 ? 1 : 0;

diag::err_vector_incorrect_num_elements)

<< LessOrMore << 3 << NumElementsArg2 <<

1;

Builtin::BI__builtin_hlsl_dot: {

Builtin::BI__builtin_hlsl_elementwise_firstbithigh:

Builtin::BI__builtin_hlsl_elementwise_firstbitlow: {

EltTy = VecTy->getElementType();

VecTy->getVectorKind());

Builtin::BI__builtin_hlsl_select: {

(VTy && VTy->getElementType()->isBooleanType() &&

Builtin::BI__builtin_hlsl_elementwise_saturate:

Builtin::BI__builtin_hlsl_elementwise_rcp: {

Builtin::BI__builtin_hlsl_elementwise_degrees:

Builtin::BI__builtin_hlsl_elementwise_radians:

Builtin::BI__builtin_hlsl_elementwise_rsqrt:

Builtin::BI__builtin_hlsl_elementwise_frac: {

Builtin::BI__builtin_hlsl_elementwise_isinf: {

Builtin::BI__builtin_hlsl_lerp: {

Builtin::BI__builtin_hlsl_mad: {

Builtin::BI__builtin_hlsl_normalize: {

Builtin::BI__builtin_hlsl_elementwise_sign: {

Builtin::BI__builtin_hlsl_step: {

Builtin::BI__builtin_hlsl_wave_active_max:

Builtin::BI__builtin_hlsl_wave_active_sum: {

TheCall->

(ArgTyExpr);

Builtin::BI__builtin_elementwise_bitreverse: {

Builtin::BI__builtin_hlsl_wave_read_lane_at: {

ArgTyIndex = Index.get()->getType();

diag::err_typecheck_convert_incompatible)

TheCall->

(ArgTyExpr);

Builtin::BI__builtin_hlsl_wave_get_lane_index: {

Builtin::BI__builtin_hlsl_elementwise_splitdouble: {

Builtin::BI__builtin_hlsl_elementwise_clip: {

Builtin::BI__builtin_elementwise_acos:

Builtin::BI__builtin_elementwise_asin:

Builtin::BI__builtin_elementwise_atan:

Builtin::BI__builtin_elementwise_atan2:

Builtin::BI__builtin_elementwise_ceil:

Builtin::BI__builtin_elementwise_cos:

Builtin::BI__builtin_elementwise_cosh:

Builtin::BI__builtin_elementwise_exp:

Builtin::BI__builtin_elementwise_exp2:

Builtin::BI__builtin_elementwise_floor:

Builtin::BI__builtin_elementwise_fmod:

Builtin::BI__builtin_elementwise_log:

Builtin::BI__builtin_elementwise_log2:

Builtin::BI__builtin_elementwise_log10:

Builtin::BI__builtin_elementwise_pow:

Builtin::BI__builtin_elementwise_roundeven:

Builtin::BI__builtin_elementwise_sin:

Builtin::BI__builtin_elementwise_sinh:

Builtin::BI__builtin_elementwise_sqrt:

Builtin::BI__builtin_elementwise_tan:

Builtin::BI__builtin_elementwise_tanh:

Builtin::BI__builtin_elementwise_trunc: {

Builtin::BI__builtin_hlsl_buffer_update_counter: {

!(ResTy->getAttrs().ResourceClass == ResourceClass::UAV &&

ResTy->getAttrs().RawBuffer && ResTy->hasContainedType());

std::optional<llvm::APSInt> Offset =

(!Offset.has_value() ||

(Offset->getExtValue()) != 1) {

diag::err_hlsl_expect_arg_const_int_one_or_neg_one)

WorkList.push_back(BaseTy);

(!WorkList.empty()) {

=

.getCanonicalType().getUnqualifiedType();

assert(!isa<MatrixType>(

) &&

);

(

*AT = dyn_cast<ConstantArrayType>(

)) {

(uint64_t Ct = 0; Ct < AT->getZExtSize(); ++Ct)

List.insert(List.end(), ElementFields.begin(), ElementFields.end());

(

*VT = dyn_cast<VectorType>(

)) {

List.insert(List.end(), VT->getNumElements(), VT->getElementType());

(

*RT = dyn_cast<RecordType>(

)) {

List.push_back(

);

(

*FD : RD->

())

FieldTypes.push_back(FD->

());

std::reverse(FieldTypes.begin(), FieldTypes.end());

WorkList.insert(WorkList.end(), FieldTypes.begin(), FieldTypes.end());

(

&

: CXXD->

())

FieldTypes.push_back(

.getType());

std::reverse(FieldTypes.begin(), FieldTypes.end());

WorkList.insert(WorkList.end(), FieldTypes.begin(), FieldTypes.end());

List.push_back(

);

ArraySize = VT->getNumElements();

ElTy = VT->getElementType();

llvm::equal(T1Types, T2Types,

HadError =

;

(

i = 0, e = New->

(); i != e; ++i) {

*NDAttr = NewParam->

<HLSLParamModifierAttr>();

NSpellingIdx = (NDAttr ? NDAttr->getSpellingListIndex() : 0);

*ODAttr = OldParam->

<HLSLParamModifierAttr>();

OSpellingIdx = (ODAttr ? ODAttr->getSpellingListIndex() : 0);

(NSpellingIdx != OSpellingIdx) {

diag::err_hlsl_param_qualifier_mismatch)

<< NDAttr << NewParam;

assert(Param->

<HLSLParamModifierAttr>() &&

);

*

= Param->

<HLSLParamModifierAttr>();

<< Arg << (IsInOut ? 1 : 0);

<< Arg << (IsInOut ? 1 : 0);

*OpV =

(Ctx)

tok::equal, ArgOpV, OpV);

*Writeback = Res.

();

);

diag::err_typecheck_decl_incomplete_type)) {

collectResourcesOnVarDecl(VD);

processExplicitBindingsOnDecl(VD);

SemaHLSL::collectResourcesOnVarDecl(

*VD) {

);

(

*CBufferOrTBuffer = dyn_cast<HLSLBufferDecl>(VD)) {

.addDeclBindingInfo(VD, CBufferOrTBuffer->isCBuffer()

? ResourceClass::CBuffer

: ResourceClass::SRV);

.addDeclBindingInfo(VD, AttrResType->getAttrs().ResourceClass);

(

*RT = dyn_cast<RecordType>(Ty))

collectResourcesOnUserRecordDecl(VD, RT);

SemaHLSL::processExplicitBindingsOnDecl(

*VD) {

HLSLResourceBindingAttr *RBA = dyn_cast<HLSLResourceBindingAttr>(A);

assert(RT != RegisterType::I &&

);

(RT == RegisterType::C) {

(

.hasBindingInfoForDecl(VD))

diag::warn_hlsl_user_defined_type_missing_member)

<<

(RT);

diag::warn_hlsl_user_defined_type_missing_member)

<<

(RT);

Defines the clang::ASTContext interface.

Defines enum values for all the target-independent builtin functions.

static bool isResourceRecordType(const clang::Type *Ty)

Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....

Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.

Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.

static bool CheckArgTypeMatches(Sema *S, Expr *Arg, QualType ExpectedType)

static void BuildFlattenedTypeList(QualType BaseTy, llvm::SmallVectorImpl< QualType > &List)

static QualType handleIntegerVectorBinOpConversion(Sema &SemaRef, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, QualType LElTy, QualType RElTy, bool IsCompAssign)

static bool convertToRegisterType(StringRef Slot, RegisterType *RT)

static bool CheckWaveActive(Sema *S, CallExpr *TheCall)

static void castVector(Sema &S, ExprResult &E, QualType &Ty, unsigned Sz)

static bool CheckBoolSelect(Sema *S, CallExpr *TheCall)

static bool CheckVectorElementCallArgs(Sema *S, CallExpr *TheCall)

static bool isZeroSizedArray(const ConstantArrayType *CAT)

static bool DiagnoseHLSLRegisterAttribute(Sema &S, SourceLocation &ArgLoc, Decl *D, RegisterType RegType, bool SpecifiedSpace)

static bool CheckUnsignedIntRepresentation(Sema *S, CallExpr *TheCall)

static bool CheckFloatingOrIntRepresentation(Sema *S, CallExpr *TheCall)

static FieldDecl * createFieldForHostLayoutStruct(Sema &S, const Type *Ty, IdentifierInfo *II, CXXRecordDecl *LayoutStruct)

static bool isInvalidConstantBufferLeafElementType(const Type *Ty)

static bool CheckNoDoubleVectors(Sema *S, CallExpr *TheCall)

static bool CheckAnyScalarOrVector(Sema *S, CallExpr *TheCall, unsigned ArgIndex)

static IdentifierInfo * getHostLayoutStructName(Sema &S, NamedDecl *BaseDecl, bool MustBeUnique)

static void SetElementTypeAsReturnType(Sema *S, CallExpr *TheCall, QualType ReturnType)

static unsigned calculateLegacyCbufferSize(const ASTContext &Context, QualType T)

static RegisterType getRegisterType(ResourceClass RC)

static bool CheckModifiableLValue(Sema *S, CallExpr *TheCall, unsigned ArgIndex)

static QualType castElement(Sema &S, ExprResult &E, QualType Ty)

static CXXRecordDecl * findRecordDeclInContext(IdentifierInfo *II, DeclContext *DC)

static bool CheckArgTypeIsCorrect(Sema *S, Expr *Arg, QualType ExpectedType, llvm::function_ref< bool(clang::QualType PassedType)> Check)

static bool CheckVectorSelect(Sema *S, CallExpr *TheCall)

static QualType handleFloatVectorBinOpConversion(Sema &SemaRef, ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, QualType LElTy, QualType RElTy, bool IsCompAssign)

static ResourceClass getResourceClass(RegisterType RT)

static CXXRecordDecl * createHostLayoutStruct(Sema &S, CXXRecordDecl *StructDecl)

static bool CheckFloatOrHalfRepresentations(Sema *S, CallExpr *TheCall)

static bool CheckScalarOrVector(Sema *S, CallExpr *TheCall, QualType Scalar, unsigned ArgIndex)

static bool CheckAllArgsHaveFloatRepresentation(Sema *S, CallExpr *TheCall)

void createHostLayoutStructForBuffer(Sema &S, HLSLBufferDecl *BufDecl)

static bool requiresImplicitBufferLayoutStructure(const CXXRecordDecl *RD)

static bool CheckResourceHandle(Sema *S, CallExpr *TheCall, unsigned ArgIndex, llvm::function_ref< bool(const HLSLAttributedResourceType *ResType)> Check=nullptr)

static void validatePackoffset(Sema &S, HLSLBufferDecl *BufDecl)

HLSLResourceBindingAttr::RegisterType RegisterType

static CastKind getScalarCastKind(ASTContext &Ctx, QualType DestTy, QualType SrcTy)

static bool isValidWaveSizeValue(unsigned Value)

static bool CheckAllArgTypesAreCorrect(Sema *S, CallExpr *TheCall, QualType ExpectedType, llvm::function_ref< bool(clang::QualType PassedType)> Check)

static bool ValidateMultipleRegisterAnnotations(Sema &S, Decl *TheDecl, RegisterType regType)

static bool DiagnoseLocalRegisterBinding(Sema &S, SourceLocation &ArgLoc, Decl *D, RegisterType RegType, bool SpecifiedSpace)

This file declares semantic analysis for HLSL constructs.

Defines the clang::SourceLocation class and associated facilities.

Defines various enumerations that describe declaration and type specifiers.

Defines the clang::TypeLoc interface and its subclasses.

C Language Family Type Representation.

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

const ConstantArrayType * getAsConstantArrayType(QualType T) const

unsigned getIntWidth(QualType T) const

int getIntegerTypeOrder(QualType LHS, QualType RHS) const

Return the highest ranked integer type, see C99 6.3.1.8p1.

bool hasSameType(QualType T1, QualType T2) const

Determine whether the given types T1 and T2 are equivalent.

QualType getVectorType(QualType VectorType, unsigned NumElts, VectorKind VecKind) const

Return the unique reference to a vector type of the specified element type and size.

QualType getPointerType(QualType T) const

Return the uniqued reference to the type for a pointer to the specified type.

QualType getLValueReferenceType(QualType T, bool SpelledAsLValue=true) const

Return the uniqued reference to the type for an lvalue reference to the specified type.

QualType getBaseElementType(const ArrayType *VAT) const

Return the innermost element type of an array type.

int getFloatingTypeOrder(QualType LHS, QualType RHS) const

Compare the rank of the two specified floating point types, ignoring the domain of the type (i....

TypeSourceInfo * getTrivialTypeSourceInfo(QualType T, SourceLocation Loc=SourceLocation()) const

Allocate a TypeSourceInfo where all locations have been initialized to a given location,...

bool hasSameUnqualifiedType(QualType T1, QualType T2) const

Determine whether the given types are equivalent after cvr-qualifiers have been removed.

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

CanQualType UnsignedIntTy

QualType getCommonSugaredType(QualType X, QualType Y, bool Unqualified=false)

QualType getExtVectorType(QualType VectorType, unsigned NumElts) const

Return the unique reference to an extended vector type of the specified element type and size.

const TargetInfo & getTargetInfo() const

QualType getCorrespondingUnsignedType(QualType T) const

QualType getHLSLAttributedResourceType(QualType Wrapped, QualType Contained, const HLSLAttributedResourceType::Attributes &Attrs)

QualType getAddrSpaceQualType(QualType T, LangAS AddressSpace) const

Return the uniqued reference to the type for an address space qualified type with the specified type ...

unsigned getTypeAlign(QualType T) const

Return the ABI-specified alignment of a (complete) type T, in bits.

QualType getElementType() const

Attr - This represents one attribute.

attr::Kind getKind() const

SourceRange getRange() const

SourceLocation getLoc() const

Represents a base class of a C++ class.

Represents a C++ struct/union/class.

void setBases(CXXBaseSpecifier const *const *Bases, unsigned NumBases)

Sets the base classes of this struct or class.

void completeDefinition() override

Indicates that the definition of this class is now complete.

bool isStandardLayout() const

Determine whether this class is standard-layout per C++ [class]p7.

unsigned getNumBases() const

Retrieves the number of base classes of this class.

static CXXRecordDecl * Create(const ASTContext &C, TagKind TK, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, CXXRecordDecl *PrevDecl=nullptr, bool DelayTypeCreation=false)

base_class_iterator bases_begin()

bool isEmpty() const

Determine whether this is an empty class in the sense of (C++11 [meta.unary.prop]).

const CXXRecordDecl * getStandardLayoutBaseWithFields() const

If this is a standard-layout class or union, any and all data members will be declared in the same ty...

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

Expr * getArg(unsigned Arg)

getArg - Return the specified argument.

SourceLocation getBeginLoc() const LLVM_READONLY

FunctionDecl * getDirectCallee()

If the callee is a FunctionDecl, return it. Otherwise return null.

unsigned getNumArgs() const

getNumArgs - Return the number of actual arguments to this call.

Represents the canonical version of C arrays with a specified constant size.

bool isZeroSize() const

Return true if the size is zero.

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

lookup_result lookup(DeclarationName Name) const

lookup - Find the declarations (if any) with the given Name in this context.

void addDecl(Decl *D)

Add the declaration D into this context.

decl_range decls() const

decls_begin/decls_end - Iterate over the declarations stored in this context.

DeclContext * getNonTransparentContext()

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

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

attr_iterator attr_end() const

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.

bool isInExportDeclContext() const

Whether this declaration was exported in a lexical context.

attr_iterator attr_begin() const

SourceLocation getLocation() const

void setImplicit(bool I=true)

DeclContext * getDeclContext()

SourceLocation getBeginLoc() const LLVM_READONLY

The name of a declaration.

SourceLocation getBeginLoc() const LLVM_READONLY

Recursive AST visitor that supports extension via dynamic dispatch.

This represents one expression.

isModifiableLvalueResult isModifiableLvalue(ASTContext &Ctx, SourceLocation *Loc=nullptr) const

isModifiableLvalue - C99 6.3.2.1: an lvalue that does not have array type, does not have an incomplet...

bool isLValue() const

isLValue - True if this expression is an "l-value" according to the rules of the current language.

Expr * IgnoreCasts() LLVM_READONLY

Skip past any casts which might surround this expression until reaching a fixed point.

void setValueKind(ExprValueKind Cat)

setValueKind - Set the value kind produced by this expression.

SourceLocation getExprLoc() const LLVM_READONLY

getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...

std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const

isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.

Represents a member of a struct/union/class.

static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)

static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)

Create a code modification hint that replaces the given source range with the given code string.

Represents a function declaration or definition.

const ParmVarDecl * getParamDecl(unsigned i) const

Stmt * getBody(const FunctionDecl *&Definition) const

Retrieve the body (definition) of the function.

bool isThisDeclarationADefinition() const

Returns whether this specific declaration of the function is also a definition that does not contain ...

ArrayRef< ParmVarDecl * > parameters() const

unsigned getNumParams() const

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

bool hasBody(const FunctionDecl *&Definition) const

Returns true if the function has a body.

static const HLSLAttributedResourceType * findHandleTypeOnResource(const Type *RT)

HLSLBufferDecl - Represent a cbuffer or tbuffer declaration.

static HLSLBufferDecl * Create(ASTContext &C, DeclContext *LexicalParent, bool CBuffer, SourceLocation KwLoc, IdentifierInfo *ID, SourceLocation IDLoc, SourceLocation LBrace)

static HLSLOutArgExpr * Create(const ASTContext &C, QualType Ty, OpaqueValueExpr *Base, OpaqueValueExpr *OpV, Expr *WB, bool IsInOut)

One of these records is kept for each identifier that is lexed.

StringRef getName() const

Return the actual identifier string.

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

Describes an entity that is being initialized.

static InitializedEntity InitializeParameter(ASTContext &Context, ParmVarDecl *Parm)

Create the initialization entity for a parameter.

MemberExpr - [C99 6.5.2.3] Structure and Union Members.

ValueDecl * getMemberDecl() const

Retrieve the member declaration to which this expression refers.

This represents a decl that may have a name.

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

StringRef getName() const

Get the name of identifier for this declaration as a StringRef.

OpaqueValueExpr - An expression referring to an opaque object of a fixed type and value class.

Represents a parameter to a function.

ParsedAttr - Represents a syntactic attribute.

unsigned getSemanticSpelling() const

If the parsed attribute has a semantic equivalent, and it would have a semantic Spelling enumeration ...

unsigned getMinArgs() const

bool checkExactlyNumArgs(class Sema &S, unsigned Num) const

Check if the attribute has exactly as many args as Num.

IdentifierLoc * getArgAsIdent(unsigned Arg) const

bool hasParsedType() const

const ParsedType & getTypeArg() const

unsigned getNumArgs() const

getNumArgs - Return the number of actual arguments to this attribute.

bool isArgIdent(unsigned Arg) const

Expr * getArgAsExpr(unsigned Arg) const

AttributeCommonInfo::Kind getKind() const

A (possibly-)qualified type.

void addRestrict()

Add the restrict qualifier to this QualType.

QualType getNonLValueExprType(const ASTContext &Context) const

Determine the type of a (typically non-lvalue) expression with the specified result type.

bool isNull() const

Return true if this QualType doesn't point to a type yet.

const Type * getTypePtr() const

Retrieves a pointer to the underlying (unqualified) type.

QualType getCanonicalType() const

QualType getUnqualifiedType() const

Retrieve the unqualified variant of the given type, removing as little sugar as possible.

Represents a struct/union/class.

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

redecl_range redecls() const

Returns an iterator range for all the redeclarations of the same decl.

bool hasBindingInfoForDecl(const VarDecl *VD) const

DeclBindingInfo * getDeclBindingInfo(const VarDecl *VD, ResourceClass ResClass)

DeclBindingInfo * addDeclBindingInfo(const VarDecl *VD, ResourceClass ResClass)

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

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

Emit a diagnostic.

ASTContext & getASTContext() const

ExprResult ActOnOutParamExpr(ParmVarDecl *Param, Expr *Arg)

void DiagnoseAttrStageMismatch(const Attr *A, llvm::Triple::EnvironmentType Stage, std::initializer_list< llvm::Triple::EnvironmentType > AllowedStages)

void handleWaveSizeAttr(Decl *D, const ParsedAttr &AL)

HLSLAttributedResourceLocInfo TakeLocForHLSLAttribute(const HLSLAttributedResourceType *RT)

QualType ProcessResourceTypeAttributes(QualType Wrapped)

void handleSV_GroupThreadIDAttr(Decl *D, const ParsedAttr &AL)

void handleShaderAttr(Decl *D, const ParsedAttr &AL)

void handleSV_DispatchThreadIDAttr(Decl *D, const ParsedAttr &AL)

void CheckEntryPoint(FunctionDecl *FD)

void emitLogicalOperatorFixIt(Expr *LHS, Expr *RHS, BinaryOperatorKind Opc)

HLSLNumThreadsAttr * mergeNumThreadsAttr(Decl *D, const AttributeCommonInfo &AL, int X, int Y, int Z)

void handlePackOffsetAttr(Decl *D, const ParsedAttr &AL)

void CheckSemanticAnnotation(FunctionDecl *EntryPoint, const Decl *Param, const HLSLAnnotationAttr *AnnotationAttr)

bool diagnoseInputIDType(QualType T, const ParsedAttr &AL)

void handleParamModifierAttr(Decl *D, const ParsedAttr &AL)

bool IsScalarizedLayoutCompatible(QualType T1, QualType T2) const

bool CheckCompatibleParameterABI(FunctionDecl *New, FunctionDecl *Old)

QualType handleVectorBinOpConversion(ExprResult &LHS, ExprResult &RHS, QualType LHSType, QualType RHSType, bool IsCompAssign)

void handleResourceBindingAttr(Decl *D, const ParsedAttr &AL)

bool IsTypedResourceElementCompatible(QualType T1)

void handleNumThreadsAttr(Decl *D, const ParsedAttr &AL)

void DiagnoseAvailabilityViolations(TranslationUnitDecl *TU)

void ActOnTopLevelFunction(FunctionDecl *FD)

bool handleResourceTypeAttr(QualType T, const ParsedAttr &AL)

HLSLShaderAttr * mergeShaderAttr(Decl *D, const AttributeCommonInfo &AL, llvm::Triple::EnvironmentType ShaderType)

void ActOnFinishBuffer(Decl *Dcl, SourceLocation RBrace)

HLSLParamModifierAttr * mergeParamModifierAttr(Decl *D, const AttributeCommonInfo &AL, HLSLParamModifierAttr::Spelling Spelling)

QualType getInoutParameterType(QualType Ty)

Decl * ActOnStartBuffer(Scope *BufferScope, bool CBuffer, SourceLocation KwLoc, IdentifierInfo *Ident, SourceLocation IdentLoc, SourceLocation LBrace)

HLSLWaveSizeAttr * mergeWaveSizeAttr(Decl *D, const AttributeCommonInfo &AL, int Min, int Max, int Preferred, int SpelledArgsCount)

void handleSV_GroupIDAttr(Decl *D, const ParsedAttr &AL)

void ActOnVariableDeclarator(VarDecl *VD)

bool CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall)

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

Scope * getCurScope() const

Retrieve the parser's current scope.

void PushOnScopeChains(NamedDecl *D, Scope *S, bool AddToContext=true)

Add this decl to the scope shadowed decl chains.

ASTContext & getASTContext() const

ExprResult ImpCastExprToType(Expr *E, QualType Type, CastKind CK, ExprValueKind VK=VK_PRValue, const CXXCastPath *BasePath=nullptr, CheckedConversionKind CCK=CheckedConversionKind::Implicit)

ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.

bool BuiltinVectorToScalarMath(CallExpr *TheCall)

bool IsLayoutCompatible(QualType T1, QualType T2) const

const LangOptions & getLangOpts() const

bool PrepareBuiltinElementwiseMathOneArgCall(CallExpr *TheCall)

DeclContext * getCurLexicalContext() const

bool checkUInt32Argument(const AttrInfo &AI, const Expr *Expr, uint32_t &Val, unsigned Idx=UINT_MAX, bool StrictlyUnsigned=false)

If Expr is a valid integer constant, get the value of the integer expression and return success or fa...

bool BuiltinElementwiseTernaryMath(CallExpr *TheCall, bool CheckForFloatArgs=true)

ExprResult ActOnBinOp(Scope *S, SourceLocation TokLoc, tok::TokenKind Kind, Expr *LHSExpr, Expr *RHSExpr)

Binary Operators. 'Tok' is the token for the operator.

bool checkArgCount(CallExpr *Call, unsigned DesiredArgCount)

Checks that a call expression's argument count is the desired number.

bool RequireCompleteType(SourceLocation Loc, QualType T, CompleteTypeKind Kind, TypeDiagnoser &Diagnoser)

Ensure that the type T is a complete type.

void PushDeclContext(Scope *S, DeclContext *DC)

Set the current declaration context until it gets popped.

ExprResult PerformCopyInitialization(const InitializedEntity &Entity, SourceLocation EqualLoc, ExprResult Init, bool TopLevelOfInitList=false, bool AllowExplicit=false)

static QualType GetTypeFromParser(ParsedType Ty, TypeSourceInfo **TInfo=nullptr)

bool checkStringLiteralArgumentAttr(const AttributeCommonInfo &CI, const Expr *E, StringRef &Str, SourceLocation *ArgLocation=nullptr)

Check if the argument E is a ASCII string literal.

Encodes a location in the source.

A trivial tuple used to represent a source range.

SourceLocation getEnd() const

SourceLocation getBegin() const

SourceLocation getEndLoc() const LLVM_READONLY

void printPretty(raw_ostream &OS, PrinterHelper *Helper, const PrintingPolicy &Policy, unsigned Indentation=0, StringRef NewlineSymbol="\n", const ASTContext *Context=nullptr) const

SourceRange getSourceRange() const LLVM_READONLY

SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...

SourceLocation getBeginLoc() const LLVM_READONLY

void startDefinition()

Starts the definition of this tag declaration.

Exposes information about the current target.

TargetOptions & getTargetOpts() const

Retrieve the target options.

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

StringRef getPlatformName() const

Retrieve the name of the platform as it is used in the availability attribute.

VersionTuple getPlatformMinVersion() const

Retrieve the minimum desired version of the platform, to which the program should be compiled.

std::string HLSLEntry

The entry point name for HLSL shader being compiled as specified by -E.

The top declaration context.

const Type * getTypeForDecl() const

SourceLocation getBeginLoc() const

Get the begin source location.

A container of type source information.

TypeLoc getTypeLoc() const

Return the TypeLoc wrapper for the type source info.

The base class of the type hierarchy.

bool isStructureType() const

CXXRecordDecl * getAsCXXRecordDecl() const

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

bool isBooleanType() const

bool isIncompleteArrayType() const

bool isConstantArrayType() const

bool isArithmeticType() const

bool isHLSLBuiltinIntangibleType() const

bool isIntegerType() const

isIntegerType() does not include complex integers (a GCC extension).

const T * castAs() const

Member-template castAs<specific type>.

bool isReferenceType() const

bool isHLSLIntangibleType() const

bool isEnumeralType() const

bool isScalarType() const

bool isIntegralType(const ASTContext &Ctx) const

Determine whether this type is an integral type.

const Type * getArrayElementTypeNoTypeQual() const

If this is an array type, return the element type of the array, potentially with type qualifiers miss...

bool hasUnsignedIntegerRepresentation() const

Determine whether this type has an unsigned integer representation of some sort, e....

bool isAggregateType() const

Determines whether the type is a C++ aggregate type or C aggregate or union type.

bool isFloat32Type() const

bool hasSignedIntegerRepresentation() const

Determine whether this type has an signed integer representation of some sort, e.g....

bool hasFloatingRepresentation() const

Determine whether this type has a floating-point representation of some sort, e.g....

bool isVectorType() const

bool isRealFloatingType() const

Floating point categories.

bool isFloatingType() const

const T * getAs() const

Member-template getAs<specific type>'.

const Type * getUnqualifiedDesugaredType() const

Return the specified type with any "sugar" removed from the type, removing any typedefs,...

bool isRecordType() const

void setType(QualType newType)

Represents a variable declaration or definition.

bool hasGlobalStorage() const

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

StorageClass getStorageClass() const

Returns the storage class as written in the source.

Represents a GCC generic vector type.

unsigned getNumElements() const

Defines the clang::TargetInfo interface.

const internal::VariadicAllOfMatcher< Attr > attr

Matches attributes.

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

@ ICIS_NoInit

No in-class initializer.

@ OK_Ordinary

An ordinary object is located at an address in memory.

@ AANT_ArgumentIdentifier

@ Result

The result type of a method or function.

@ Ordinary

This parameter uses ordinary ABI rules for its type.

ActionResult< Expr * > ExprResult

bool CreateHLSLAttributedResourceType(Sema &S, QualType Wrapped, ArrayRef< const Attr * > AttrList, QualType &ResType, HLSLAttributedResourceLocInfo *LocInfo=nullptr)

CastKind

CastKind - The kind of operation required for a conversion.

@ VK_LValue

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

const FunctionProtoType * T

@ Generic

not a target-specific vector type

Diagnostic wrappers for TextAPI types for error reporting.

__DEVICE__ _Tp abs(const std::complex< _Tp > &__c)

TypeSourceInfo * ContainedTyInfo

llvm::dxil::ResourceClass ResourceClass

Wraps an identifier and optional source location for the identifier.

Describes how types, statements, expressions, and declarations should be printed.

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