dd3d7cfe2e
- Defines a new declaration node `HLSLRootSignature` in `DeclNodes.td` that will consist of a `TrailingObjects` of the in-memory construction of the root signature, namely an array of `hlsl::rootsig::RootElement`s - Defines a new clang attr `RootSignature` which simply holds an identifier to a corresponding root signature declaration as above - Integrate the `HLSLRootSignatureParser` to construct the decl node in `ParseMicrosoftAttributes` and then attach the parsed attr with an identifier to the entry point function declaration. - Defines the various required declaration methods - Add testing that the declaration and reference attr are created correctly, and some syntactical error tests. It was previously proposed that we could have the root elements reference be stored directly as an additional member of the attribute and to not have a separate root signature decl. In contrast, by defining them separately as this change proposes, we will allow a unique root signature to have its own declaration in the AST tree. This allows us to only construct a single root signature for all duplicate root signature attributes. Having it located directly as a declaration might also prove advantageous when we consider root signature libraries. Resolves https://github.com/llvm/llvm-project/issues/119011
514 lines
15 KiB
C++
514 lines
15 KiB
C++
//===--- ASTCommon.cpp - Common stuff for ASTReader/ASTWriter----*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines common functions that both ASTReader and ASTWriter use.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "ASTCommon.h"
|
|
#include "clang/AST/DeclCXX.h"
|
|
#include "clang/AST/DeclObjC.h"
|
|
#include "clang/Basic/IdentifierTable.h"
|
|
#include "clang/Serialization/ASTDeserializationListener.h"
|
|
#include "clang/Serialization/ModuleFile.h"
|
|
#include "llvm/Support/DJB.h"
|
|
#include "llvm/Support/FileSystem.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
using namespace clang;
|
|
|
|
// Give ASTDeserializationListener's VTable a home.
|
|
ASTDeserializationListener::~ASTDeserializationListener() { }
|
|
|
|
serialization::TypeIdx
|
|
serialization::TypeIdxFromBuiltin(const BuiltinType *BT) {
|
|
unsigned ID = 0;
|
|
switch (BT->getKind()) {
|
|
case BuiltinType::Void:
|
|
ID = PREDEF_TYPE_VOID_ID;
|
|
break;
|
|
case BuiltinType::Bool:
|
|
ID = PREDEF_TYPE_BOOL_ID;
|
|
break;
|
|
case BuiltinType::Char_U:
|
|
ID = PREDEF_TYPE_CHAR_U_ID;
|
|
break;
|
|
case BuiltinType::UChar:
|
|
ID = PREDEF_TYPE_UCHAR_ID;
|
|
break;
|
|
case BuiltinType::UShort:
|
|
ID = PREDEF_TYPE_USHORT_ID;
|
|
break;
|
|
case BuiltinType::UInt:
|
|
ID = PREDEF_TYPE_UINT_ID;
|
|
break;
|
|
case BuiltinType::ULong:
|
|
ID = PREDEF_TYPE_ULONG_ID;
|
|
break;
|
|
case BuiltinType::ULongLong:
|
|
ID = PREDEF_TYPE_ULONGLONG_ID;
|
|
break;
|
|
case BuiltinType::UInt128:
|
|
ID = PREDEF_TYPE_UINT128_ID;
|
|
break;
|
|
case BuiltinType::Char_S:
|
|
ID = PREDEF_TYPE_CHAR_S_ID;
|
|
break;
|
|
case BuiltinType::SChar:
|
|
ID = PREDEF_TYPE_SCHAR_ID;
|
|
break;
|
|
case BuiltinType::WChar_S:
|
|
case BuiltinType::WChar_U:
|
|
ID = PREDEF_TYPE_WCHAR_ID;
|
|
break;
|
|
case BuiltinType::Short:
|
|
ID = PREDEF_TYPE_SHORT_ID;
|
|
break;
|
|
case BuiltinType::Int:
|
|
ID = PREDEF_TYPE_INT_ID;
|
|
break;
|
|
case BuiltinType::Long:
|
|
ID = PREDEF_TYPE_LONG_ID;
|
|
break;
|
|
case BuiltinType::LongLong:
|
|
ID = PREDEF_TYPE_LONGLONG_ID;
|
|
break;
|
|
case BuiltinType::Int128:
|
|
ID = PREDEF_TYPE_INT128_ID;
|
|
break;
|
|
case BuiltinType::Half:
|
|
ID = PREDEF_TYPE_HALF_ID;
|
|
break;
|
|
case BuiltinType::Float:
|
|
ID = PREDEF_TYPE_FLOAT_ID;
|
|
break;
|
|
case BuiltinType::Double:
|
|
ID = PREDEF_TYPE_DOUBLE_ID;
|
|
break;
|
|
case BuiltinType::LongDouble:
|
|
ID = PREDEF_TYPE_LONGDOUBLE_ID;
|
|
break;
|
|
case BuiltinType::ShortAccum:
|
|
ID = PREDEF_TYPE_SHORT_ACCUM_ID;
|
|
break;
|
|
case BuiltinType::Accum:
|
|
ID = PREDEF_TYPE_ACCUM_ID;
|
|
break;
|
|
case BuiltinType::LongAccum:
|
|
ID = PREDEF_TYPE_LONG_ACCUM_ID;
|
|
break;
|
|
case BuiltinType::UShortAccum:
|
|
ID = PREDEF_TYPE_USHORT_ACCUM_ID;
|
|
break;
|
|
case BuiltinType::UAccum:
|
|
ID = PREDEF_TYPE_UACCUM_ID;
|
|
break;
|
|
case BuiltinType::ULongAccum:
|
|
ID = PREDEF_TYPE_ULONG_ACCUM_ID;
|
|
break;
|
|
case BuiltinType::ShortFract:
|
|
ID = PREDEF_TYPE_SHORT_FRACT_ID;
|
|
break;
|
|
case BuiltinType::Fract:
|
|
ID = PREDEF_TYPE_FRACT_ID;
|
|
break;
|
|
case BuiltinType::LongFract:
|
|
ID = PREDEF_TYPE_LONG_FRACT_ID;
|
|
break;
|
|
case BuiltinType::UShortFract:
|
|
ID = PREDEF_TYPE_USHORT_FRACT_ID;
|
|
break;
|
|
case BuiltinType::UFract:
|
|
ID = PREDEF_TYPE_UFRACT_ID;
|
|
break;
|
|
case BuiltinType::ULongFract:
|
|
ID = PREDEF_TYPE_ULONG_FRACT_ID;
|
|
break;
|
|
case BuiltinType::SatShortAccum:
|
|
ID = PREDEF_TYPE_SAT_SHORT_ACCUM_ID;
|
|
break;
|
|
case BuiltinType::SatAccum:
|
|
ID = PREDEF_TYPE_SAT_ACCUM_ID;
|
|
break;
|
|
case BuiltinType::SatLongAccum:
|
|
ID = PREDEF_TYPE_SAT_LONG_ACCUM_ID;
|
|
break;
|
|
case BuiltinType::SatUShortAccum:
|
|
ID = PREDEF_TYPE_SAT_USHORT_ACCUM_ID;
|
|
break;
|
|
case BuiltinType::SatUAccum:
|
|
ID = PREDEF_TYPE_SAT_UACCUM_ID;
|
|
break;
|
|
case BuiltinType::SatULongAccum:
|
|
ID = PREDEF_TYPE_SAT_ULONG_ACCUM_ID;
|
|
break;
|
|
case BuiltinType::SatShortFract:
|
|
ID = PREDEF_TYPE_SAT_SHORT_FRACT_ID;
|
|
break;
|
|
case BuiltinType::SatFract:
|
|
ID = PREDEF_TYPE_SAT_FRACT_ID;
|
|
break;
|
|
case BuiltinType::SatLongFract:
|
|
ID = PREDEF_TYPE_SAT_LONG_FRACT_ID;
|
|
break;
|
|
case BuiltinType::SatUShortFract:
|
|
ID = PREDEF_TYPE_SAT_USHORT_FRACT_ID;
|
|
break;
|
|
case BuiltinType::SatUFract:
|
|
ID = PREDEF_TYPE_SAT_UFRACT_ID;
|
|
break;
|
|
case BuiltinType::SatULongFract:
|
|
ID = PREDEF_TYPE_SAT_ULONG_FRACT_ID;
|
|
break;
|
|
case BuiltinType::Float16:
|
|
ID = PREDEF_TYPE_FLOAT16_ID;
|
|
break;
|
|
case BuiltinType::Float128:
|
|
ID = PREDEF_TYPE_FLOAT128_ID;
|
|
break;
|
|
case BuiltinType::Ibm128:
|
|
ID = PREDEF_TYPE_IBM128_ID;
|
|
break;
|
|
case BuiltinType::NullPtr:
|
|
ID = PREDEF_TYPE_NULLPTR_ID;
|
|
break;
|
|
case BuiltinType::Char8:
|
|
ID = PREDEF_TYPE_CHAR8_ID;
|
|
break;
|
|
case BuiltinType::Char16:
|
|
ID = PREDEF_TYPE_CHAR16_ID;
|
|
break;
|
|
case BuiltinType::Char32:
|
|
ID = PREDEF_TYPE_CHAR32_ID;
|
|
break;
|
|
case BuiltinType::Overload:
|
|
ID = PREDEF_TYPE_OVERLOAD_ID;
|
|
break;
|
|
case BuiltinType::UnresolvedTemplate:
|
|
ID = PREDEF_TYPE_UNRESOLVED_TEMPLATE;
|
|
break;
|
|
case BuiltinType::BoundMember:
|
|
ID = PREDEF_TYPE_BOUND_MEMBER;
|
|
break;
|
|
case BuiltinType::PseudoObject:
|
|
ID = PREDEF_TYPE_PSEUDO_OBJECT;
|
|
break;
|
|
case BuiltinType::Dependent:
|
|
ID = PREDEF_TYPE_DEPENDENT_ID;
|
|
break;
|
|
case BuiltinType::UnknownAny:
|
|
ID = PREDEF_TYPE_UNKNOWN_ANY;
|
|
break;
|
|
case BuiltinType::ARCUnbridgedCast:
|
|
ID = PREDEF_TYPE_ARC_UNBRIDGED_CAST;
|
|
break;
|
|
case BuiltinType::ObjCId:
|
|
ID = PREDEF_TYPE_OBJC_ID;
|
|
break;
|
|
case BuiltinType::ObjCClass:
|
|
ID = PREDEF_TYPE_OBJC_CLASS;
|
|
break;
|
|
case BuiltinType::ObjCSel:
|
|
ID = PREDEF_TYPE_OBJC_SEL;
|
|
break;
|
|
#define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
|
|
case BuiltinType::Id: \
|
|
ID = PREDEF_TYPE_##Id##_ID; \
|
|
break;
|
|
#include "clang/Basic/OpenCLImageTypes.def"
|
|
#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
|
|
case BuiltinType::Id: \
|
|
ID = PREDEF_TYPE_##Id##_ID; \
|
|
break;
|
|
#include "clang/Basic/OpenCLExtensionTypes.def"
|
|
case BuiltinType::OCLSampler:
|
|
ID = PREDEF_TYPE_SAMPLER_ID;
|
|
break;
|
|
case BuiltinType::OCLEvent:
|
|
ID = PREDEF_TYPE_EVENT_ID;
|
|
break;
|
|
case BuiltinType::OCLClkEvent:
|
|
ID = PREDEF_TYPE_CLK_EVENT_ID;
|
|
break;
|
|
case BuiltinType::OCLQueue:
|
|
ID = PREDEF_TYPE_QUEUE_ID;
|
|
break;
|
|
case BuiltinType::OCLReserveID:
|
|
ID = PREDEF_TYPE_RESERVE_ID_ID;
|
|
break;
|
|
#define SVE_TYPE(Name, Id, SingletonId) \
|
|
case BuiltinType::Id: \
|
|
ID = PREDEF_TYPE_##Id##_ID; \
|
|
break;
|
|
#include "clang/Basic/AArch64SVEACLETypes.def"
|
|
#define PPC_VECTOR_TYPE(Name, Id, Size) \
|
|
case BuiltinType::Id: \
|
|
ID = PREDEF_TYPE_##Id##_ID; \
|
|
break;
|
|
#include "clang/Basic/PPCTypes.def"
|
|
#define RVV_TYPE(Name, Id, SingletonId) \
|
|
case BuiltinType::Id: \
|
|
ID = PREDEF_TYPE_##Id##_ID; \
|
|
break;
|
|
#include "clang/Basic/RISCVVTypes.def"
|
|
#define WASM_TYPE(Name, Id, SingletonId) \
|
|
case BuiltinType::Id: \
|
|
ID = PREDEF_TYPE_##Id##_ID; \
|
|
break;
|
|
#include "clang/Basic/WebAssemblyReferenceTypes.def"
|
|
#define AMDGPU_TYPE(Name, Id, SingletonId, Width, Align) \
|
|
case BuiltinType::Id: \
|
|
ID = PREDEF_TYPE_##Id##_ID; \
|
|
break;
|
|
#include "clang/Basic/AMDGPUTypes.def"
|
|
#define HLSL_INTANGIBLE_TYPE(Name, Id, SingletonId) \
|
|
case BuiltinType::Id: \
|
|
ID = PREDEF_TYPE_##Id##_ID; \
|
|
break;
|
|
#include "clang/Basic/HLSLIntangibleTypes.def"
|
|
case BuiltinType::BuiltinFn:
|
|
ID = PREDEF_TYPE_BUILTIN_FN;
|
|
break;
|
|
case BuiltinType::IncompleteMatrixIdx:
|
|
ID = PREDEF_TYPE_INCOMPLETE_MATRIX_IDX;
|
|
break;
|
|
case BuiltinType::ArraySection:
|
|
ID = PREDEF_TYPE_ARRAY_SECTION;
|
|
break;
|
|
case BuiltinType::OMPArrayShaping:
|
|
ID = PREDEF_TYPE_OMP_ARRAY_SHAPING;
|
|
break;
|
|
case BuiltinType::OMPIterator:
|
|
ID = PREDEF_TYPE_OMP_ITERATOR;
|
|
break;
|
|
case BuiltinType::BFloat16:
|
|
ID = PREDEF_TYPE_BFLOAT16_ID;
|
|
break;
|
|
}
|
|
|
|
return TypeIdx(0, ID);
|
|
}
|
|
|
|
unsigned serialization::ComputeHash(Selector Sel) {
|
|
unsigned N = Sel.getNumArgs();
|
|
if (N == 0)
|
|
++N;
|
|
unsigned R = 5381;
|
|
for (unsigned I = 0; I != N; ++I)
|
|
if (const IdentifierInfo *II = Sel.getIdentifierInfoForSlot(I))
|
|
R = llvm::djbHash(II->getName(), R);
|
|
return R;
|
|
}
|
|
|
|
const DeclContext *
|
|
serialization::getDefinitiveDeclContext(const DeclContext *DC) {
|
|
switch (DC->getDeclKind()) {
|
|
// These entities may have multiple definitions.
|
|
case Decl::TranslationUnit:
|
|
case Decl::ExternCContext:
|
|
case Decl::Namespace:
|
|
case Decl::LinkageSpec:
|
|
case Decl::Export:
|
|
return nullptr;
|
|
|
|
// C/C++ tag types can only be defined in one place.
|
|
case Decl::Enum:
|
|
case Decl::Record:
|
|
if (const TagDecl *Def = cast<TagDecl>(DC)->getDefinition())
|
|
return Def;
|
|
return nullptr;
|
|
|
|
// FIXME: These can be defined in one place... except special member
|
|
// functions and out-of-line definitions.
|
|
case Decl::CXXRecord:
|
|
case Decl::ClassTemplateSpecialization:
|
|
case Decl::ClassTemplatePartialSpecialization:
|
|
return nullptr;
|
|
|
|
// Each function, method, and block declaration is its own DeclContext.
|
|
case Decl::Function:
|
|
case Decl::CXXMethod:
|
|
case Decl::CXXConstructor:
|
|
case Decl::CXXDestructor:
|
|
case Decl::CXXConversion:
|
|
case Decl::ObjCMethod:
|
|
case Decl::Block:
|
|
case Decl::OutlinedFunction:
|
|
case Decl::Captured:
|
|
// Objective C categories, category implementations, and class
|
|
// implementations can only be defined in one place.
|
|
case Decl::ObjCCategory:
|
|
case Decl::ObjCCategoryImpl:
|
|
case Decl::ObjCImplementation:
|
|
return DC;
|
|
|
|
case Decl::ObjCProtocol:
|
|
if (const ObjCProtocolDecl *Def
|
|
= cast<ObjCProtocolDecl>(DC)->getDefinition())
|
|
return Def;
|
|
return nullptr;
|
|
|
|
// FIXME: These are defined in one place, but properties in class extensions
|
|
// end up being back-patched into the main interface. See
|
|
// SemaObjC::HandlePropertyInClassExtension for the offending code.
|
|
case Decl::ObjCInterface:
|
|
return nullptr;
|
|
|
|
default:
|
|
llvm_unreachable("Unhandled DeclContext in AST reader");
|
|
}
|
|
|
|
llvm_unreachable("Unhandled decl kind");
|
|
}
|
|
|
|
bool serialization::isRedeclarableDeclKind(unsigned Kind) {
|
|
switch (static_cast<Decl::Kind>(Kind)) {
|
|
case Decl::TranslationUnit:
|
|
case Decl::ExternCContext:
|
|
// Special case of a "merged" declaration.
|
|
return true;
|
|
|
|
case Decl::Namespace:
|
|
case Decl::NamespaceAlias:
|
|
case Decl::Typedef:
|
|
case Decl::TypeAlias:
|
|
case Decl::Enum:
|
|
case Decl::Record:
|
|
case Decl::CXXRecord:
|
|
case Decl::ClassTemplateSpecialization:
|
|
case Decl::ClassTemplatePartialSpecialization:
|
|
case Decl::VarTemplateSpecialization:
|
|
case Decl::VarTemplatePartialSpecialization:
|
|
case Decl::Function:
|
|
case Decl::CXXDeductionGuide:
|
|
case Decl::CXXMethod:
|
|
case Decl::CXXConstructor:
|
|
case Decl::CXXDestructor:
|
|
case Decl::CXXConversion:
|
|
case Decl::UsingShadow:
|
|
case Decl::ConstructorUsingShadow:
|
|
case Decl::Var:
|
|
case Decl::FunctionTemplate:
|
|
case Decl::ClassTemplate:
|
|
case Decl::VarTemplate:
|
|
case Decl::TypeAliasTemplate:
|
|
case Decl::ObjCProtocol:
|
|
case Decl::ObjCInterface:
|
|
case Decl::Empty:
|
|
return true;
|
|
|
|
// Never redeclarable.
|
|
case Decl::UsingDirective:
|
|
case Decl::Label:
|
|
case Decl::UnresolvedUsingTypename:
|
|
case Decl::TemplateTypeParm:
|
|
case Decl::EnumConstant:
|
|
case Decl::UnresolvedUsingValue:
|
|
case Decl::IndirectField:
|
|
case Decl::Field:
|
|
case Decl::MSProperty:
|
|
case Decl::MSGuid:
|
|
case Decl::UnnamedGlobalConstant:
|
|
case Decl::TemplateParamObject:
|
|
case Decl::ObjCIvar:
|
|
case Decl::ObjCAtDefsField:
|
|
case Decl::NonTypeTemplateParm:
|
|
case Decl::TemplateTemplateParm:
|
|
case Decl::Using:
|
|
case Decl::UsingEnum:
|
|
case Decl::UsingPack:
|
|
case Decl::ObjCMethod:
|
|
case Decl::ObjCCategory:
|
|
case Decl::ObjCCategoryImpl:
|
|
case Decl::ObjCImplementation:
|
|
case Decl::ObjCProperty:
|
|
case Decl::ObjCCompatibleAlias:
|
|
case Decl::LinkageSpec:
|
|
case Decl::Export:
|
|
case Decl::ObjCPropertyImpl:
|
|
case Decl::PragmaComment:
|
|
case Decl::PragmaDetectMismatch:
|
|
case Decl::FileScopeAsm:
|
|
case Decl::TopLevelStmt:
|
|
case Decl::AccessSpec:
|
|
case Decl::Friend:
|
|
case Decl::FriendTemplate:
|
|
case Decl::StaticAssert:
|
|
case Decl::Block:
|
|
case Decl::OutlinedFunction:
|
|
case Decl::Captured:
|
|
case Decl::Import:
|
|
case Decl::OMPThreadPrivate:
|
|
case Decl::OMPAllocate:
|
|
case Decl::OMPRequires:
|
|
case Decl::OMPCapturedExpr:
|
|
case Decl::OMPDeclareReduction:
|
|
case Decl::OMPDeclareMapper:
|
|
case Decl::BuiltinTemplate:
|
|
case Decl::Decomposition:
|
|
case Decl::Binding:
|
|
case Decl::Concept:
|
|
case Decl::ImplicitConceptSpecialization:
|
|
case Decl::LifetimeExtendedTemporary:
|
|
case Decl::RequiresExprBody:
|
|
case Decl::UnresolvedUsingIfExists:
|
|
case Decl::HLSLBuffer:
|
|
case Decl::HLSLRootSignature:
|
|
case Decl::OpenACCDeclare:
|
|
case Decl::OpenACCRoutine:
|
|
return false;
|
|
|
|
// These indirectly derive from Redeclarable<T> but are not actually
|
|
// redeclarable.
|
|
case Decl::ImplicitParam:
|
|
case Decl::ParmVar:
|
|
case Decl::ObjCTypeParam:
|
|
return false;
|
|
}
|
|
|
|
llvm_unreachable("Unhandled declaration kind");
|
|
}
|
|
|
|
bool serialization::needsAnonymousDeclarationNumber(const NamedDecl *D) {
|
|
// Friend declarations in dependent contexts aren't anonymous in the usual
|
|
// sense, but they cannot be found by name lookup in their semantic context
|
|
// (or indeed in any context), so we treat them as anonymous.
|
|
//
|
|
// This doesn't apply to friend tag decls; Sema makes those available to name
|
|
// lookup in the surrounding context.
|
|
if (D->getFriendObjectKind() &&
|
|
D->getLexicalDeclContext()->isDependentContext() && !isa<TagDecl>(D)) {
|
|
// For function templates and class templates, the template is numbered and
|
|
// not its pattern.
|
|
if (auto *FD = dyn_cast<FunctionDecl>(D))
|
|
return !FD->getDescribedFunctionTemplate();
|
|
if (auto *RD = dyn_cast<CXXRecordDecl>(D))
|
|
return !RD->getDescribedClassTemplate();
|
|
return true;
|
|
}
|
|
|
|
// At block scope, we number everything that we need to deduplicate, since we
|
|
// can't just use name matching to keep things lined up.
|
|
// FIXME: This is only necessary for an inline function or a template or
|
|
// similar.
|
|
if (D->getLexicalDeclContext()->isFunctionOrMethod()) {
|
|
if (auto *VD = dyn_cast<VarDecl>(D))
|
|
return VD->isStaticLocal();
|
|
// FIXME: What about CapturedDecls (and declarations nested within them)?
|
|
return isa<TagDecl, BlockDecl>(D);
|
|
}
|
|
|
|
// Otherwise, we only care about anonymous class members / block-scope decls.
|
|
// FIXME: We need to handle blocks within inline / templated variables too.
|
|
if (D->getDeclName())
|
|
return false;
|
|
if (!isa<RecordDecl, ObjCInterfaceDecl>(D->getLexicalDeclContext()))
|
|
return false;
|
|
return isa<TagDecl, FieldDecl>(D);
|
|
}
|