SemaHLSL.h

Go to the documentation of this file.

//===----- SemaHLSL.h ----- Semantic Analysis for HLSL constructs ---------===//
//
// 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
//
//===----------------------------------------------------------------------===//
/// \file
/// This file declares semantic analysis for HLSL constructs.
///
//===----------------------------------------------------------------------===//
 
#ifndef LLVM_CLANG_SEMA_SEMAHLSL_H
#define LLVM_CLANG_SEMA_SEMAHLSL_H
 
#include "clang/AST/ASTFwd.h"
#include "clang/AST/Attr.h"
#include "clang/AST/Type.h"
#include "clang/AST/TypeLoc.h"
#include "clang/Basic/DiagnosticSema.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Sema/SemaBase.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/Frontend/HLSL/SemanticSignatures.h"
#include "llvm/TargetParser/Triple.h"
#include <initializer_list>
 
namespace clang {
class AttributeCommonInfo;
class IdentifierInfo;
class InitializedEntity;
class InitializationKind;
class ParsedAttr;
class Scope;
class VarDecl;
 
namespace hlsl {
 
// Introduce a wrapper struct around the underlying RootElement. This structure
// will retain extra clang diagnostic information that is not available in llvm.
struct RootSignatureElement {
  RootSignatureElement(SourceLocation Loc,
                       llvm::hlsl::rootsig::RootElement Element)
      : Loc(Loc), Element(Element) {}
 
  const llvm::hlsl::rootsig::RootElement &getElement() const { return Element; }
  const SourceLocation &getLocation() const { return Loc; }
 
private:
  SourceLocation Loc;
  llvm::hlsl::rootsig::RootElement Element;
};
 
} // namespace hlsl
 
using llvm::dxil::ResourceClass;
 
// FIXME: This can be hidden (as static function in SemaHLSL.cpp) once we no
// longer need to create builtin buffer types in HLSLExternalSemaSource.
bool CreateHLSLAttributedResourceType(
    Sema &S, QualType Wrapped, ArrayRef<const Attr *> AttrList,
    QualType &ResType, HLSLAttributedResourceLocInfo *LocInfo = nullptr,
    Expr *SampleCountExpr = nullptr);
 
enum class BindingType : uint8_t { NotAssigned, Explicit, Implicit };
 
// DeclBindingInfo struct stores information about required/assigned resource
// binding onon a declaration for specific resource class.
struct DeclBindingInfo {
  const VarDecl *Decl;
  ResourceClass ResClass;
  const HLSLResourceBindingAttr *Attr;
  BindingType BindType;
 
  DeclBindingInfo(const VarDecl *Decl, ResourceClass ResClass,
                  BindingType BindType = BindingType::NotAssigned,
                  const HLSLResourceBindingAttr *Attr = nullptr)
      : Decl(Decl), ResClass(ResClass), Attr(Attr), BindType(BindType) {}
 
  void setBindingAttribute(HLSLResourceBindingAttr *A, BindingType BT) {
    assert(Attr == nullptr && BindType == BindingType::NotAssigned &&
           "binding attribute already assigned");
    Attr = A;
    BindType = BT;
  }
};
 
// ResourceBindings class stores information about all resource bindings
// in a shader. It is used for binding diagnostics and implicit binding
// assignments.
class ResourceBindings {
public:
  DeclBindingInfo *addDeclBindingInfo(const VarDecl *VD,
                                      ResourceClass ResClass);
  DeclBindingInfo *getDeclBindingInfo(const VarDecl *VD,
                                      ResourceClass ResClass);
  bool hasBindingInfoForDecl(const VarDecl *VD) const;
 
private:
  // List of all resource bindings required by the shader.
  // A global declaration can have multiple bindings for different
  // resource classes. They are all stored sequentially in this list.
  // The DeclToBindingListIndex hashtable maps a declaration to the
  // index of the first binding info in the list.
  llvm::SmallVector<DeclBindingInfo> BindingsList;
  llvm::DenseMap<const VarDecl *, unsigned> DeclToBindingListIndex;
};
 
class SemaHLSL : public SemaBase {
public:
  SemaHLSL(Sema &S);
 
  Decl *ActOnStartBuffer(Scope *BufferScope, bool CBuffer, SourceLocation KwLoc,
                         IdentifierInfo *Ident, SourceLocation IdentLoc,
                         SourceLocation LBrace);
  void ActOnFinishBuffer(Decl *Dcl, SourceLocation RBrace);
  HLSLNumThreadsAttr *mergeNumThreadsAttr(Decl *D,
                                          const AttributeCommonInfo &AL, int X,
                                          int Y, int Z);
  HLSLWaveSizeAttr *mergeWaveSizeAttr(Decl *D, const AttributeCommonInfo &AL,
                                      int Min, int Max, int Preferred,
                                      int SpelledArgsCount);
  HLSLVkConstantIdAttr *
  mergeVkConstantIdAttr(Decl *D, const AttributeCommonInfo &AL, int Id);
  HLSLShaderAttr *mergeShaderAttr(Decl *D, const AttributeCommonInfo &AL,
                                  llvm::Triple::EnvironmentType ShaderType);
  HLSLParamModifierAttr *
  mergeParamModifierAttr(Decl *D, const AttributeCommonInfo &AL,
                         HLSLParamModifierAttr::Spelling Spelling);
  void ActOnTopLevelFunction(FunctionDecl *FD);
  void ActOnVariableDeclarator(VarDecl *VD);
  bool ActOnUninitializedVarDecl(VarDecl *D);
  void ActOnEndOfTranslationUnit(TranslationUnitDecl *TU);
  bool ActOnResourceMemberAccessExpr(MemberExpr *ME);
  void CheckEntryPoint(FunctionDecl *FD);
 
  // Return true if everything is ok; returns false if there was an error.
  bool CheckResourceBinOp(BinaryOperatorKind Opc, Expr *LHSExpr, Expr *RHSExpr,
                          SourceLocation Loc);
 
  bool canHaveOverloadedBinOp(QualType Ty, BinaryOperatorKind Opc);
 
  QualType handleVectorBinOpConversion(ExprResult &LHS, ExprResult &RHS,
                                       QualType LHSType, QualType RHSType,
                                       bool IsCompAssign);
  void emitLogicalOperatorFixIt(Expr *LHS, Expr *RHS, BinaryOperatorKind Opc);
 
  // Returns the result of converting ConstantBuffer<T> to
  // `const hlsl_constant T&`. If `BaseExpr`'s type is not ConstantBuffer<T>
  // then the return value is `std::nullopt`.
  std::optional<ExprResult> tryPerformConstantBufferConversion(Expr *BaseExpr);
 
  // Returns the conversion operator to convert `RD` to `const hlsl_constant
  // Type&`. Returns `nullptr` if it could not be found.
  NamedDecl *getConstantBufferConversionFunction(QualType Type,
                                                 CXXRecordDecl *RD);
 
  /// Computes the unique Root Signature identifier from the given signature,
  /// then lookup if there is a previousy created Root Signature decl.
  ///
  /// Returns the identifier and if it was found
  std::pair<IdentifierInfo *, bool>
  ActOnStartRootSignatureDecl(StringRef Signature);
 
  /// Creates the Root Signature decl of the parsed Root Signature elements
  /// onto the AST and push it onto current Scope
  void
  ActOnFinishRootSignatureDecl(SourceLocation Loc, IdentifierInfo *DeclIdent,
                               ArrayRef<hlsl::RootSignatureElement> Elements);
 
  void SetRootSignatureOverride(IdentifierInfo *DeclIdent) {
    RootSigOverrideIdent = DeclIdent;
  }
 
  HLSLRootSignatureDecl *lookupRootSignatureOverrideDecl(DeclContext *DC) const;
 
  // Returns true if any RootSignatureElement is invalid and a diagnostic was
  // produced
  bool
  handleRootSignatureElements(ArrayRef<hlsl::RootSignatureElement> Elements);
  void handleRootSignatureAttr(Decl *D, const ParsedAttr &AL);
  void handleNumThreadsAttr(Decl *D, const ParsedAttr &AL);
  void handleWaveSizeAttr(Decl *D, const ParsedAttr &AL);
  void handleVkConstantIdAttr(Decl *D, const ParsedAttr &AL);
  void handleVkBindingAttr(Decl *D, const ParsedAttr &AL);
  void handleVkLocationAttr(Decl *D, const ParsedAttr &AL);
  void handlePackOffsetAttr(Decl *D, const ParsedAttr &AL);
  void handleShaderAttr(Decl *D, const ParsedAttr &AL);
  void handleResourceBindingAttr(Decl *D, const ParsedAttr &AL);
  void handleParamModifierAttr(Decl *D, const ParsedAttr &AL);
  Attr *buildMatrixLayoutTypeAttr(QualType T, const ParsedAttr &AL);
  bool diagnoseMatrixLayoutInstantiation(attr::Kind K, QualType T,
                                         SourceLocation Loc);
  // Re-type a layout-adapting matrix builtin call \p E with \p DestType's
  // row_major/column_major sugar so CodeGen lowers it into that layout.
  void propagateContextualMatrixLayout(Expr *E, QualType DestType);
  bool handleResourceTypeAttr(QualType T, const ParsedAttr &AL);
 
  template <typename T>
  T *createSemanticAttr(const AttributeCommonInfo &ACI,
                        std::optional<unsigned> Location) {
    return ::new (getASTContext())
        T(getASTContext(), ACI, ACI.getAttrName()->getName(),
          Location.value_or(0));
  }
 
  void diagnoseSystemSemanticAttr(Decl *D, const ParsedAttr &AL,
                                  llvm::dxbc::PSV::SemanticKind SemanticKind,
                                  std::optional<unsigned> Index);
  void handleSemanticAttr(Decl *D, const ParsedAttr &AL);
 
  void handleVkExtBuiltinInputAttr(Decl *D, const ParsedAttr &AL);
  void handleVkExtBuiltinOutputAttr(Decl *D, const ParsedAttr &AL);
  void handleVkPushConstantAttr(Decl *D, const ParsedAttr &AL);
 
  bool CheckBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall);
  QualType ProcessResourceTypeAttributes(QualType Wrapped);
  HLSLAttributedResourceLocInfo
  TakeLocForHLSLAttribute(const HLSLAttributedResourceType *RT);
 
  // HLSL Type trait implementations
  bool IsScalarizedLayoutCompatible(QualType T1, QualType T2) const;
  bool IsTypedResourceElementCompatible(QualType T1);
  bool IsConstantBufferElementCompatible(QualType T1);
 
  bool CheckCompatibleParameterABI(FunctionDecl *New, FunctionDecl *Old);
 
  QualType ActOnTemplateShorthand(TemplateDecl *Template,
                                  SourceLocation NameLoc);
 
  // Diagnose whether the index type is uint/unit2/uint3 type.
  bool diagnoseIndexType(QualType T, const ParsedAttr &AL);
  // Diagnose whether the type is float/float2/float3/float4 type.
  bool diagnoseFloatType(QualType T, const ParsedAttr &AL);
 
  bool CanPerformScalarCast(QualType SrcTy, QualType DestTy);
  bool CanPerformElementwiseCast(Expr *Src, QualType DestType);
  bool CanPerformAggregateSplatCast(Expr *Src, QualType DestType);
  ExprResult ActOnOutParamExpr(ParmVarDecl *Param, Expr *Arg);
 
  QualType getInoutParameterType(QualType Ty);
 
  bool transformInitList(const InitializedEntity &Entity, InitListExpr *Init);
  bool handleInitialization(VarDecl *VDecl, Expr *&Init);
  void deduceAddressSpace(VarDecl *Decl);
  QualType checkMatrixComponent(Sema &S, QualType baseType, ExprValueKind &VK,
                                SourceLocation OpLoc,
                                const IdentifierInfo *CompName,
                                SourceLocation CompLoc);
 
  uint32_t getNextImplicitBindingOrderID() {
    return ImplicitBindingNextOrderID++;
  }
 
  bool initGlobalResourceDecl(VarDecl *VD);
  bool initGlobalResourceArrayDecl(VarDecl *VD);
 
private:
  // HLSL resource type attributes need to be processed all at once.
  // This is a list to collect them.
  llvm::SmallVector<const Attr *> HLSLResourcesTypeAttrs;
 
  /// TypeLoc data for HLSLAttributedResourceType instances that we
  /// have not yet populated.
  llvm::DenseMap<const HLSLAttributedResourceType *,
                 HLSLAttributedResourceLocInfo>
      LocsForHLSLAttributedResources;
 
  // List of all resource bindings
  ResourceBindings Bindings;
 
  // Map of local resource variables to their assigned global resources.
  //
  // The binding can be a nullptr, in which case, the variable has yet to be
  // initialized or assigned to.
  llvm::DenseMap<const VarDecl *, const DeclBindingInfo *> Assigns;
 
  // Global declaration collected for the $Globals default constant
  // buffer which will be created at the end of the translation unit.
  llvm::SmallVector<Decl *> DefaultCBufferDecls;
 
  uint32_t ImplicitBindingNextOrderID = 0;
 
  IdentifierInfo *RootSigOverrideIdent = nullptr;
 
  bool HasDeclaredAPushConstant = false;
 
  // Information about the current subtree being flattened.
  struct SemanticInfo {
    HLSLParsedSemanticAttr *Semantic;
    std::optional<uint32_t> Index = std::nullopt;
  };
 
  // The context shared by all semantics with the same IOType during
  // flattening.
  struct SemanticContext {
    // Present if any semantic sharing the same IO type has an explicit or
    // implicit SPIR-V location index assigned.
    std::optional<bool> UsesExplicitVkLocations = std::nullopt;
    // The set of semantics found to be active during flattening. Used to detect
    // index collisions.
    llvm::StringSet<> ActiveSemantics = {};
    // The IOType of this semantic set.
    llvm::hlsl::IOType CurrentIOType;
  };
 
private:
  void collectResourceBindingsOnVarDecl(VarDecl *D);
  void collectResourceBindingsOnUserRecordDecl(const VarDecl *VD,
                                               const RecordType *RT);
 
  void checkSemanticAnnotation(FunctionDecl *EntryPoint, const Decl *Param,
                               const HLSLAppliedSemanticAttr *SemanticAttr,
                               const SemanticContext &SC);
 
  bool determineActiveSemanticOnScalar(FunctionDecl *FD,
                                       DeclaratorDecl *OutputDecl,
                                       DeclaratorDecl *D,
                                       SemanticInfo &ActiveSemantic,
                                       SemanticContext &SC);
 
  bool determineActiveSemantic(FunctionDecl *FD, DeclaratorDecl *OutputDecl,
                               DeclaratorDecl *D, SemanticInfo &ActiveSemantic,
                               SemanticContext &SC);
 
  void processExplicitBindingsOnDecl(VarDecl *D);
 
  void diagnoseAvailabilityViolations(TranslationUnitDecl *TU);
 
  void diagnoseAttrStageMismatch(
      const Attr *A, llvm::Triple::EnvironmentType Stage,
      std::initializer_list<llvm::Triple::EnvironmentType> AllowedStages);
 
  void
  diagnoseSemanticStageMismatch(const Attr *A,
                                llvm::Triple::EnvironmentType Stage,
                                llvm::hlsl::IOType CurrentIOType,
                                llvm::dxbc::PSV::SemanticKind SemanticKind);
 
  void handleGlobalStructOrArrayOfWithResources(VarDecl *VD);
 
  // Infer a common global binding info for an Expr
  //
  // Returns std::nullopt if the expr refers to non-unique global bindings.
  // Returns nullptr if it refer to any global binding, otherwise it returns
  // a reference to the global binding info.
  std::optional<const DeclBindingInfo *> inferGlobalBinding(Expr *E);
 
  void trackLocalResource(VarDecl *VDecl, Expr *E);
};
 
} // namespace clang
 
#endif // LLVM_CLANG_SEMA_SEMAHLSL_H