llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang @llvm/pr-subscribers-hlsl Author: Sarah Spall (spall) <details> <summary>Changes</summary> Implement HLSL Flat casting excluding splat cases Partly closes #<!-- -->100609 and #<!-- -->100619 --- Patch is 40.86 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/118842.diff 19 Files Affected: - (modified) clang/include/clang/AST/OperationKinds.def (+3) - (modified) clang/include/clang/Sema/SemaHLSL.h (+2) - (modified) clang/lib/AST/Expr.cpp (+1) - (modified) clang/lib/AST/ExprConstant.cpp (+1) - (modified) clang/lib/CodeGen/CGExpr.cpp (+86) - (modified) clang/lib/CodeGen/CGExprAgg.cpp (+78-1) - (modified) clang/lib/CodeGen/CGExprComplex.cpp (+1) - (modified) clang/lib/CodeGen/CGExprConstant.cpp (+1) - (modified) clang/lib/CodeGen/CGExprScalar.cpp (+40) - (modified) clang/lib/CodeGen/CodeGenFunction.h (+8) - (modified) clang/lib/Edit/RewriteObjCFoundationAPI.cpp (+1) - (modified) clang/lib/Sema/Sema.cpp (+1) - (modified) clang/lib/Sema/SemaCast.cpp (+19-3) - (modified) clang/lib/Sema/SemaHLSL.cpp (+144) - (modified) clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp (+1) - (added) clang/test/CodeGenHLSL/BasicFeatures/ArrayFlatCast.hlsl (+128) - (added) clang/test/CodeGenHLSL/BasicFeatures/StructFlatCast.hlsl (+124) - (added) clang/test/CodeGenHLSL/BasicFeatures/VectorFlatCast.hlsl (+81) - (modified) clang/test/SemaHLSL/BuiltIns/vector-constructors-erros.hlsl (-2) ``````````diff diff --git a/clang/include/clang/AST/OperationKinds.def b/clang/include/clang/AST/OperationKinds.def index 8788b8ff0ef0a4..9323d4e861a734 100644 --- a/clang/include/clang/AST/OperationKinds.def +++ b/clang/include/clang/AST/OperationKinds.def @@ -367,6 +367,9 @@ CAST_OPERATION(HLSLVectorTruncation) // Non-decaying array RValue cast (HLSL only). CAST_OPERATION(HLSLArrayRValue) +// Aggregate by Value cast (HLSL only). +CAST_OPERATION(HLSLAggregateCast) + //===- Binary Operations -------------------------------------------------===// // Operators listed in order of precedence. // Note that additions to this should also update the StmtVisitor class, diff --git a/clang/include/clang/Sema/SemaHLSL.h b/clang/include/clang/Sema/SemaHLSL.h index ee685d95c96154..6bda1e8ce0ea5b 100644 --- a/clang/include/clang/Sema/SemaHLSL.h +++ b/clang/include/clang/Sema/SemaHLSL.h @@ -140,6 +140,8 @@ class SemaHLSL : public SemaBase { // Diagnose whether the input ID is uint/unit2/uint3 type. bool diagnoseInputIDType(QualType T, const ParsedAttr &AL); + bool CanPerformScalarCast(QualType SrcTy, QualType DestTy); + bool CanPerformAggregateCast(Expr *Src, QualType DestType); ExprResult ActOnOutParamExpr(ParmVarDecl *Param, Expr *Arg); QualType getInoutParameterType(QualType Ty); diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp index a4fb4d5a1f2ec4..4764bc84ce498a 100644 --- a/clang/lib/AST/Expr.cpp +++ b/clang/lib/AST/Expr.cpp @@ -1942,6 +1942,7 @@ bool CastExpr::CastConsistency() const { case CK_FixedPointToBoolean: case CK_HLSLArrayRValue: case CK_HLSLVectorTruncation: + case CK_HLSLAggregateCast: CheckNoBasePath: assert(path_empty() && "Cast kind should not have a base path!"); break; diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp index 6b5b95aee35522..b548cef41b7525 100644 --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -15733,6 +15733,7 @@ bool ComplexExprEvaluator::VisitCastExpr(const CastExpr *E) { case CK_IntegralToFixedPoint: case CK_MatrixCast: case CK_HLSLVectorTruncation: + case CK_HLSLAggregateCast: llvm_unreachable("invalid cast kind for complex value"); case CK_LValueToRValue: diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp index 5fccc9cbb37ec1..6b9c437ef7e242 100644 --- a/clang/lib/CodeGen/CGExpr.cpp +++ b/clang/lib/CodeGen/CGExpr.cpp @@ -5320,6 +5320,7 @@ LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { case CK_MatrixCast: case CK_HLSLVectorTruncation: case CK_HLSLArrayRValue: + case CK_HLSLAggregateCast: return EmitUnsupportedLValue(E, "unexpected cast lvalue"); case CK_Dependent: @@ -6358,3 +6359,88 @@ RValue CodeGenFunction::EmitPseudoObjectRValue(const PseudoObjectExpr *E, LValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) { return emitPseudoObjectExpr(*this, E, true, AggValueSlot::ignored()).LV; } + +llvm::Value * +CodeGenFunction::PerformLoad(std::pair<Address, llvm::Value *> &GEP) { + Address GEPAddress = GEP.first; + llvm::Value *Idx = GEP.second; + llvm::Value *V = Builder.CreateLoad(GEPAddress, "load"); + if (Idx) { // loading from a vector so perform an extract as well + return Builder.CreateExtractElement(V, Idx, "vec.load"); + } + return V; +} + +llvm::Value * +CodeGenFunction::PerformStore(std::pair<Address, llvm::Value *> &GEP, + llvm::Value *Val) { + Address GEPAddress = GEP.first; + llvm::Value *Idx = GEP.second; + if (Idx) { + llvm::Value *V = Builder.CreateLoad(GEPAddress, "load.for.insert"); + return Builder.CreateInsertElement(V, Val, Idx); + } else { + return Builder.CreateStore(Val, GEPAddress); + } +} + +void CodeGenFunction::FlattenAccessAndType( + Address Val, QualType SrcTy, SmallVector<llvm::Value *, 4> &IdxList, + SmallVector<std::pair<Address, llvm::Value *>, 16> &GEPList, + SmallVector<QualType> &FlatTypes) { + llvm::IntegerType *IdxTy = llvm::IntegerType::get(getLLVMContext(), 32); + if (const ConstantArrayType *CAT = dyn_cast<ConstantArrayType>(SrcTy)) { + uint64_t Size = CAT->getZExtSize(); + for (unsigned i = 0; i < Size; i++) { + // flatten each member of the array + // add index of this element to index list + llvm::Value *Idx = llvm::ConstantInt::get(IdxTy, i); + IdxList.push_back(Idx); + // recur on this object + FlattenAccessAndType(Val, CAT->getElementType(), IdxList, GEPList, + FlatTypes); + // remove index of this element from index list + IdxList.pop_back(); + } + } else if (const RecordType *RT = SrcTy->getAs<RecordType>()) { + RecordDecl *Record = RT->getDecl(); + const CGRecordLayout &RL = getTypes().getCGRecordLayout(Record); + // do I need to check if its a cxx record decl? + + for (auto fieldIter = Record->field_begin(), fieldEnd = Record->field_end(); + fieldIter != fieldEnd; ++fieldIter) { + // get the field number + unsigned FieldNum = RL.getLLVMFieldNo(*fieldIter); + // can we just do *fieldIter->getFieldIndex(); + // add that index to the index list + llvm::Value *Idx = llvm::ConstantInt::get(IdxTy, FieldNum); + IdxList.push_back(Idx); + // recur on the field + FlattenAccessAndType(Val, fieldIter->getType(), IdxList, GEPList, + FlatTypes); + // remove index of this element from index list + IdxList.pop_back(); + } + } else if (const VectorType *VT = SrcTy->getAs<VectorType>()) { + llvm::Type *VTy = ConvertTypeForMem(SrcTy); + CharUnits Align = getContext().getTypeAlignInChars(SrcTy); + Address GEP = + Builder.CreateInBoundsGEP(Val, IdxList, VTy, Align, "vector.gep"); + for (unsigned i = 0; i < VT->getNumElements(); i++) { + // add index to the list + llvm::Value *Idx = llvm::ConstantInt::get(IdxTy, i); + // create gep. no need to recur since its always a scalar + // gep on vector is not recommended so combine gep with extract/insert + GEPList.push_back({GEP, Idx}); + FlatTypes.push_back(VT->getElementType()); + } + } else { // should be a scalar should we assert or check? + // create a gep + llvm::Type *Ty = ConvertTypeForMem(SrcTy); + CharUnits Align = getContext().getTypeAlignInChars(SrcTy); + Address GEP = Builder.CreateInBoundsGEP(Val, IdxList, Ty, Align, "gep"); + GEPList.push_back({GEP, NULL}); + FlatTypes.push_back(SrcTy); + } + // target extension types? +} diff --git a/clang/lib/CodeGen/CGExprAgg.cpp b/clang/lib/CodeGen/CGExprAgg.cpp index 2ad6587089f101..e3b47de958ce55 100644 --- a/clang/lib/CodeGen/CGExprAgg.cpp +++ b/clang/lib/CodeGen/CGExprAgg.cpp @@ -491,6 +491,65 @@ static bool isTrivialFiller(Expr *E) { return false; } +// emit a flat cast where the RHS is a scalar, including vector +static void EmitHLSLScalarFlatCast(CodeGenFunction &CGF, Address DestVal, + QualType DestTy, llvm::Value *SrcVal, + QualType SrcTy, SourceLocation Loc) { + // Flatten our destination + SmallVector<QualType> DestTypes; // Flattened type + SmallVector<llvm::Value *, 4> IdxList; + SmallVector<std::pair<Address, llvm::Value *>, 16> StoreGEPList; + // ^^ Flattened accesses to DestVal we want to store into + CGF.FlattenAccessAndType(DestVal, DestTy, IdxList, StoreGEPList, DestTypes); + + if (const VectorType *VT = SrcTy->getAs<VectorType>()) { + SrcTy = VT->getElementType(); + assert(StoreGEPList.size() <= VT->getNumElements() && + "Cannot perform HLSL flat cast when vector source \ + object has less elements than flattened destination \ + object."); + for (unsigned i = 0; i < StoreGEPList.size(); i++) { + llvm::Value *Load = + CGF.Builder.CreateExtractElement(SrcVal, i, "vec.load"); + llvm::Value *Cast = + CGF.EmitScalarConversion(Load, SrcTy, DestTypes[i], Loc); + CGF.PerformStore(StoreGEPList[i], Cast); + } + return; + } + llvm_unreachable("HLSL Flat cast doesn't handle splatting."); +} + +// emit a flat cast where the RHS is an aggregate +static void EmitHLSLAggregateFlatCast(CodeGenFunction &CGF, Address DestVal, + QualType DestTy, Address SrcVal, + QualType SrcTy, SourceLocation Loc) { + // Flatten our destination + SmallVector<QualType> DestTypes; // Flattened type + SmallVector<llvm::Value *, 4> IdxList; + SmallVector<std::pair<Address, llvm::Value *>, 16> StoreGEPList; + // ^^ Flattened accesses to DestVal we want to store into + CGF.FlattenAccessAndType(DestVal, DestTy, IdxList, StoreGEPList, DestTypes); + // Flatten our src + SmallVector<QualType> SrcTypes; // Flattened type + SmallVector<std::pair<Address, llvm::Value *>, 16> LoadGEPList; + // ^^ Flattened accesses to SrcVal we want to load from + IdxList.clear(); + CGF.FlattenAccessAndType(SrcVal, SrcTy, IdxList, LoadGEPList, SrcTypes); + + assert(StoreGEPList.size() <= LoadGEPList.size() && + "Cannot perform HLSL flat cast when flattened source object \ + has less elements than flattened destination object."); + // apply casts to what we load from LoadGEPList + // and store result in Dest + for (unsigned i = 0; i < StoreGEPList.size(); i++) { + llvm::Value *Load = CGF.PerformLoad(LoadGEPList[i]); + llvm::Value *Cast = + CGF.EmitScalarConversion(Load, SrcTypes[i], DestTypes[i], Loc); + CGF.PerformStore(StoreGEPList[i], Cast); + } +} + /// Emit initialization of an array from an initializer list. ExprToVisit must /// be either an InitListEpxr a CXXParenInitListExpr. void AggExprEmitter::EmitArrayInit(Address DestPtr, llvm::ArrayType *AType, @@ -890,7 +949,25 @@ void AggExprEmitter::VisitCastExpr(CastExpr *E) { case CK_HLSLArrayRValue: Visit(E->getSubExpr()); break; - + case CK_HLSLAggregateCast: { + Expr *Src = E->getSubExpr(); + QualType SrcTy = Src->getType(); + RValue RV = CGF.EmitAnyExpr(Src); + QualType DestTy = E->getType(); + Address DestVal = Dest.getAddress(); + SourceLocation Loc = E->getExprLoc(); + + if (RV.isScalar()) { + llvm::Value *SrcVal = RV.getScalarVal(); + EmitHLSLScalarFlatCast(CGF, DestVal, DestTy, SrcVal, SrcTy, Loc); + } else { // RHS is an aggregate + assert(RV.isAggregate() && + "Can't perform HLSL Aggregate cast on a complex type."); + Address SrcVal = RV.getAggregateAddress(); + EmitHLSLAggregateFlatCast(CGF, DestVal, DestTy, SrcVal, SrcTy, Loc); + } + break; + } case CK_NoOp: case CK_UserDefinedConversion: case CK_ConstructorConversion: diff --git a/clang/lib/CodeGen/CGExprComplex.cpp b/clang/lib/CodeGen/CGExprComplex.cpp index ac31dff11b585e..05680d36aa2bd7 100644 --- a/clang/lib/CodeGen/CGExprComplex.cpp +++ b/clang/lib/CodeGen/CGExprComplex.cpp @@ -610,6 +610,7 @@ ComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op, case CK_MatrixCast: case CK_HLSLVectorTruncation: case CK_HLSLArrayRValue: + case CK_HLSLAggregateCast: llvm_unreachable("invalid cast kind for complex value"); case CK_FloatingRealToComplex: diff --git a/clang/lib/CodeGen/CGExprConstant.cpp b/clang/lib/CodeGen/CGExprConstant.cpp index 655fc3dc954c81..6d15bc9058e450 100644 --- a/clang/lib/CodeGen/CGExprConstant.cpp +++ b/clang/lib/CodeGen/CGExprConstant.cpp @@ -1335,6 +1335,7 @@ class ConstExprEmitter case CK_MatrixCast: case CK_HLSLVectorTruncation: case CK_HLSLArrayRValue: + case CK_HLSLAggregateCast: return nullptr; } llvm_unreachable("Invalid CastKind"); diff --git a/clang/lib/CodeGen/CGExprScalar.cpp b/clang/lib/CodeGen/CGExprScalar.cpp index 4ae8a2b22b1bba..3809e3b1db3494 100644 --- a/clang/lib/CodeGen/CGExprScalar.cpp +++ b/clang/lib/CodeGen/CGExprScalar.cpp @@ -2262,6 +2262,36 @@ bool CodeGenFunction::ShouldNullCheckClassCastValue(const CastExpr *CE) { return true; } +// RHS is an aggregate type +static Value *EmitHLSLAggregateFlatCast(CodeGenFunction &CGF, Address RHSVal, + QualType RHSTy, QualType LHSTy, + SourceLocation Loc) { + SmallVector<llvm::Value *, 4> IdxList; + SmallVector<std::pair<Address, llvm::Value *>, 16> LoadGEPList; + SmallVector<QualType> SrcTypes; // Flattened type + CGF.FlattenAccessAndType(RHSVal, RHSTy, IdxList, LoadGEPList, SrcTypes); + // LHS is either a vector or a builtin? + // if its a vector create a temp alloca to store into and return that + if (auto *VecTy = LHSTy->getAs<VectorType>()) { + llvm::Value *V = + CGF.Builder.CreateLoad(CGF.CreateIRTemp(LHSTy, "flatcast.tmp")); + // write to V. + for (unsigned i = 0; i < VecTy->getNumElements(); i++) { + llvm::Value *Load = CGF.PerformLoad(LoadGEPList[i]); + llvm::Value *Cast = CGF.EmitScalarConversion( + Load, SrcTypes[i], VecTy->getElementType(), Loc); + V = CGF.Builder.CreateInsertElement(V, Cast, i); + } + return V; + } + // i its a builtin just do an extract element or load. + assert(LHSTy->isBuiltinType() && + "Destination type must be a vector or builtin type."); + // TODO add asserts about things being long enough + return CGF.EmitScalarConversion(CGF.PerformLoad(LoadGEPList[0]), LHSTy, + SrcTypes[0], Loc); +} + // VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts // have to handle a more broad range of conversions than explicit casts, as they // handle things like function to ptr-to-function decay etc. @@ -2752,7 +2782,17 @@ Value *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { llvm::Value *Zero = llvm::Constant::getNullValue(CGF.SizeTy); return Builder.CreateExtractElement(Vec, Zero, "cast.vtrunc"); } + case CK_HLSLAggregateCast: { + RValue RV = CGF.EmitAnyExpr(E); + SourceLocation Loc = CE->getExprLoc(); + QualType SrcTy = E->getType(); + if (RV.isAggregate()) { // RHS is an aggregate + Address SrcVal = RV.getAggregateAddress(); + return EmitHLSLAggregateFlatCast(CGF, SrcVal, SrcTy, DestTy, Loc); + } + llvm_unreachable("Not a valid HLSL Flat Cast."); + } } // end of switch llvm_unreachable("unknown scalar cast"); diff --git a/clang/lib/CodeGen/CodeGenFunction.h b/clang/lib/CodeGen/CodeGenFunction.h index eaea0d8a08ac06..873dd781eb2e7d 100644 --- a/clang/lib/CodeGen/CodeGenFunction.h +++ b/clang/lib/CodeGen/CodeGenFunction.h @@ -4359,6 +4359,14 @@ class CodeGenFunction : public CodeGenTypeCache { AggValueSlot slot = AggValueSlot::ignored()); LValue EmitPseudoObjectLValue(const PseudoObjectExpr *e); + llvm::Value *PerformLoad(std::pair<Address, llvm::Value *> &GEP); + llvm::Value *PerformStore(std::pair<Address, llvm::Value *> &GEP, + llvm::Value *Val); + void FlattenAccessAndType( + Address Val, QualType SrcTy, SmallVector<llvm::Value *, 4> &IdxList, + SmallVector<std::pair<Address, llvm::Value *>, 16> &GEPList, + SmallVector<QualType> &FlatTypes); + llvm::Value *EmitIvarOffset(const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar); llvm::Value *EmitIvarOffsetAsPointerDiff(const ObjCInterfaceDecl *Interface, diff --git a/clang/lib/Edit/RewriteObjCFoundationAPI.cpp b/clang/lib/Edit/RewriteObjCFoundationAPI.cpp index 81797c8c4dc75a..63308319a78d1c 100644 --- a/clang/lib/Edit/RewriteObjCFoundationAPI.cpp +++ b/clang/lib/Edit/RewriteObjCFoundationAPI.cpp @@ -1085,6 +1085,7 @@ static bool rewriteToNumericBoxedExpression(const ObjCMessageExpr *Msg, llvm_unreachable("OpenCL-specific cast in Objective-C?"); case CK_HLSLVectorTruncation: + case CK_HLSLAggregateCast: llvm_unreachable("HLSL-specific cast in Objective-C?"); break; diff --git a/clang/lib/Sema/Sema.cpp b/clang/lib/Sema/Sema.cpp index d6517511d7db4d..2f0528d6ab5ce1 100644 --- a/clang/lib/Sema/Sema.cpp +++ b/clang/lib/Sema/Sema.cpp @@ -707,6 +707,7 @@ ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty, case CK_ToVoid: case CK_NonAtomicToAtomic: case CK_HLSLArrayRValue: + case CK_HLSLAggregateCast: break; } } diff --git a/clang/lib/Sema/SemaCast.cpp b/clang/lib/Sema/SemaCast.cpp index f98857f852b5af..0bd7fc91aee18f 100644 --- a/clang/lib/Sema/SemaCast.cpp +++ b/clang/lib/Sema/SemaCast.cpp @@ -23,6 +23,7 @@ #include "clang/Basic/TargetInfo.h" #include "clang/Lex/Preprocessor.h" #include "clang/Sema/Initialization.h" +#include "clang/Sema/SemaHLSL.h" #include "clang/Sema/SemaObjC.h" #include "clang/Sema/SemaRISCV.h" #include "llvm/ADT/SmallVector.h" @@ -2768,6 +2769,24 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle, return; } + CheckedConversionKind CCK = FunctionalStyle + ? CheckedConversionKind::FunctionalCast + : CheckedConversionKind::CStyleCast; + // todo what else should i be doing lvalue to rvalue cast for? + // why dont they do it for records below? + // This case should not trigger on regular vector splat + // Or vector cast or vector truncation. + QualType SrcTy = SrcExpr.get()->getType(); + if (Self.getLangOpts().HLSL && + Self.HLSL().CanPerformAggregateCast(SrcExpr.get(), DestType)) { + if (SrcTy->isConstantArrayType()) + SrcExpr = Self.ImpCastExprToType( + SrcExpr.get(), Self.Context.getArrayParameterType(SrcTy), + CK_HLSLArrayRValue, VK_PRValue, nullptr, CCK); + Kind = CK_HLSLAggregateCast; + return; + } + if (ValueKind == VK_PRValue && !DestType->isRecordType() && !isPlaceholder(BuiltinType::Overload)) { SrcExpr = Self.DefaultFunctionArrayLvalueConversion(SrcExpr.get()); @@ -2820,9 +2839,6 @@ void CastOperation::CheckCXXCStyleCast(bool FunctionalStyle, if (isValidCast(tcr)) Kind = CK_NoOp; - CheckedConversionKind CCK = FunctionalStyle - ? CheckedConversionKind::FunctionalCast - : CheckedConversionKind::CStyleCast; if (tcr == TC_NotApplicable) { tcr = TryAddressSpaceCast(Self, SrcExpr, DestType, /*CStyle*/ true, msg, Kind); diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 88db3e12541193..5c7af8056063ad 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -2412,6 +2412,150 @@ bool SemaHLSL::CheckCompatibleParameterABI(FunctionDecl *New, return HadError; } +// Follows PerformScalarCast +bool SemaHLSL::CanPerformScalarCast(QualType SrcTy, QualType DestTy) { + + if (SemaRef.getASTContext().hasSameUnqualifiedType(SrcTy, DestTy)) + return true; + + switch (Type::ScalarTypeKind SrcKind = SrcTy->getScalarTypeKind()) { + case Type::STK_MemberPointer: + return false; + + case Type::STK_CPointer: + case Type::STK_BlockPointer: + case Type::STK_ObjCObjectPointer: + switch (DestTy->getScalarTypeKind()) { + case Type::STK_CPointer: + case Type::STK_BlockPointer: + case Type::STK_ObjCObjectPointer: + case Type::STK_Bool: + case Type::STK_Integral: + return true; + case Type::STK_Floating: + case Type::STK_FloatingComplex: + case Type::STK_IntegralComplex: + case Type::STK_MemberPointer: + return false; + case Type::STK_FixedPoint: + llvm_unreachable("HLSL doesn't have fixed point types."); + } + llvm_unreachable("Should have returned before this"); + + case Type::STK_FixedPoint: + llvm_unreachable("HLSL doesn't have fixed point types."); + + case Type::STK_Bool: // casting from bool is like casting from an integer + case Type::STK_Integral: + switch (DestTy->getScalarTypeKind()) { + case Type::STK_CPointer: + case Type::STK_ObjCObjectPointer: + case Type::STK_BlockPointer: + case Type::STK_Bool: + case Type::STK_Integral: + case Type::STK_Floating: + case Type::STK_IntegralComplex: + case Type::STK_FloatingComplex: + return true; + case Type::STK_FixedPoint: + llvm_unreachable("HLSL doesn't have fixed point types."); + case Type::STK_MemberPointer: + return false; + } + llvm_unreachable("Should have returned before this"); + + case Type::STK_Floating: + switch (DestTy->getScalarT... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/118842 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
