llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-clang Author: Chinmay Deshpande (chinmaydd) <details> <summary>Changes</summary> Expose the `llvm.convert.from.arbitrary.fp` intrinsic as a target-independent builtin. It reinterprets an integer as the bits of a narrow floating-point format that has no corresponding C type, and widens it to a native floating-point type: ``` _Float16 h = __builtin_convert_from_arbitrary_fp(b, "Float8E4M3FN", _Float16); ``` Since the destination type cannot be derived from the arguments, it is passed as a type argument and the builtin is parsed as a keyword, following the `__builtin_convertvector` precedent. The format is a string literal validated with `APFloatBase::isValidArbitraryFPFormat`, so every format the IR verifier accepts is accepted here; formats that no target lowers yet keep being reported by the backend. The integer operand may be any integer type whose width matches the format, which covers char/unsigned char for the 8-bit formats and `_BitInt` for the narrower ones. Vector operands are supported with matching element counts. Clang only permits `_BitInt` vector elements of power-of-two width, so vectors of the 6-bit formats cannot be spelled. NOTE: Support for `__builtin_convert_to_arbitrary_fp` will follow. AI Disclosure: Most of this PR was generated with the help of an LLM, but I have reviewed every line of it. --- Patch is 61.84 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/212647.diff 40 Files Affected: - (modified) clang/docs/LanguageExtensions.md (+55) - (modified) clang/docs/ReleaseNotes.md (+2) - (modified) clang/include/clang/AST/ComputeDependence.h (+2) - (modified) clang/include/clang/AST/Expr.h (+66) - (modified) clang/include/clang/AST/RecursiveASTVisitor.h (+3) - (modified) clang/include/clang/Basic/Builtins.td (+6) - (modified) clang/include/clang/Basic/DiagnosticSemaKinds.td (+22) - (modified) clang/include/clang/Basic/StmtNodes.td (+1) - (modified) clang/include/clang/Basic/TokenKinds.def (+1) - (modified) clang/include/clang/Sema/Sema.h (+20) - (modified) clang/include/clang/Serialization/ASTBitCodes.h (+3) - (modified) clang/lib/AST/ASTImporter.cpp (+18) - (modified) clang/lib/AST/ComputeDependence.cpp (+9) - (modified) clang/lib/AST/Expr.cpp (+1) - (modified) clang/lib/AST/ExprClassification.cpp (+1) - (modified) clang/lib/AST/ExprConstant.cpp (+1) - (modified) clang/lib/AST/ItaniumMangle.cpp (+11) - (modified) clang/lib/AST/StmtPrinter.cpp (+11) - (modified) clang/lib/AST/StmtProfile.cpp (+6) - (modified) clang/lib/CodeGen/CGExprScalar.cpp (+14) - (modified) clang/lib/Parse/ParseExpr.cpp (+42) - (modified) clang/lib/Sema/SemaChecking.cpp (+114) - (modified) clang/lib/Sema/SemaExceptionSpec.cpp (+1) - (modified) clang/lib/Sema/SemaExpr.cpp (+9) - (modified) clang/lib/Sema/TreeTransform.h (+32) - (modified) clang/lib/Serialization/ASTReaderStmt.cpp (+14) - (modified) clang/lib/Serialization/ASTWriterStmt.cpp (+11) - (modified) clang/lib/StaticAnalyzer/Core/ExprEngine.cpp (+1) - (modified) clang/test/AST/ast-dump-expr.c (+8) - (added) clang/test/CodeGen/builtins-convert-from-arbitrary-fp.c (+194) - (modified) clang/test/CodeGenCXX/mangle-exprs.cpp (+18) - (added) clang/test/Index/convert-from-arbitrary-fp.c (+14) - (modified) clang/test/PCH/exprs.c (+3) - (modified) clang/test/PCH/exprs.h (+5) - (added) clang/test/Sema/builtins-convert-from-arbitrary-fp-rvv.c (+9) - (added) clang/test/Sema/builtins-convert-from-arbitrary-fp.c (+89) - (added) clang/test/SemaCXX/builtins-convert-from-arbitrary-fp.cpp (+60) - (added) clang/test/SemaOpenCL/builtins-convert-from-arbitrary-fp.cl (+5) - (modified) clang/tools/libclang/CIndex.cpp (+6) - (modified) clang/tools/libclang/CXCursor.cpp (+1) ``````````diff diff --git a/clang/docs/LanguageExtensions.md b/clang/docs/LanguageExtensions.md index f5313e0378ca0..087d9e15855ca 100644 --- a/clang/docs/LanguageExtensions.md +++ b/clang/docs/LanguageExtensions.md @@ -3610,6 +3610,61 @@ C-style cast applied to each element of the first argument. Query for this feature with `__has_builtin(__builtin_convertvector)`. +(langext-__builtin_convert_from_arbitrary_fp)= +(langext-builtin-convert-from-arbitrary-fp)= + +### `__builtin_convert_from_arbitrary_fp` + +`__builtin_convert_from_arbitrary_fp` interprets an integer as the bits of a value in a narrow floating-point format that has no corresponding C type, and converts it to a native floating-point type. + +**Syntax**: + +```c++ +__builtin_convert_from_arbitrary_fp(bits, format, dst_type) +``` + +**Examples**: + +```c++ +typedef unsigned char uchar4 __attribute__((ext_vector_type(4))); +typedef float float4 __attribute__((ext_vector_type(4))); + +unsigned char b; uchar4 vb; + +// Interpret b as a Float8E4M3FN value and widen it to _Float16. +__builtin_convert_from_arbitrary_fp(b, "Float8E4M3FN", _Float16) + +// The same, elementwise, for four Float8E5M2 values. +__builtin_convert_from_arbitrary_fp(vb, "Float8E5M2", float4) +``` + +**Description**: + +`bits` is an integer, or a vector of integers, holding the encoded floating-point value. +`format` must be an ordinary string literal naming the source format. +`dst_type` must be a floating-point type, or a vector of floating-point types with the same number of elements as `bits`. +Supported destination element semantics are IEEE half, bfloat16, IEEE single, and IEEE double. +Other destination types, including types with x87 extended, PPC double-double, or IEEE quad semantics and the `__mfp8` type, are rejected. +Vector source and destination operands must be fixed-length vectors; sizeless SVE and RVV vectors are rejected. +The width of `bits` (its element width, for vectors) must equal the width of `format`. + +Clang's target-independent semantic analysis accepts all verifier-valid format names: + +- 8-bit: `"Float8E5M2"`, `"Float8E5M2FNUZ"`, `"Float8E4M3"`, `"Float8E4M3FN"`, + `"Float8E4M3FNUZ"`, `"Float8E4M3B11FNUZ"`, `"Float8E3M4"`, `"Float8E8M0FNU"` +- 6-bit: `"Float6E3M2FN"`, `"Float6E2M3FN"` +- 4-bit: `"Float4E2M1FN"` + +Only the signedness-free width of `bits` matters, so for an 8-bit format any of `char`, `signed char`, `unsigned char`, or `_BitInt(8)` of either signedness may be used. +The 6-bit and 4-bit formats require a `_BitInt` of the matching width. +Because Clang only permits `_BitInt` vector elements whose width is a power of two, vectors of the 6-bit formats cannot be expressed. + +This builtin maps to the `llvm.convert.from.arbitrary.fp` intrinsic; see its description in the LLVM Language Reference for the exact conversion semantics. +Backend lowering is currently implemented only for `"Float8E5M2"`, `"Float8E4M3FN"`, `"Float6E3M2FN"`, `"Float6E2M3FN"`, and `"Float4E2M1FN"`; this does not guarantee support on any particular target. +The other verifier-accepted formats, `"Float8E5M2FNUZ"`, `"Float8E4M3"`, `"Float8E4M3FNUZ"`, `"Float8E4M3B11FNUZ"`, `"Float8E3M4"`, and `"Float8E8M0FNU"`, can be emitted to LLVM IR but currently fail during backend lowering. + +Query for this feature with `__has_builtin(__builtin_convert_from_arbitrary_fp)`. + ### `__builtin_bitreverse` - `__builtin_bitreverse8` diff --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md index f631d9f858f9f..2ae50448d49d6 100644 --- a/clang/docs/ReleaseNotes.md +++ b/clang/docs/ReleaseNotes.md @@ -146,6 +146,8 @@ features cannot lower the translation-unit ABI level; ### Non-comprehensive list of changes in this release +- Added `__builtin_convert_from_arbitrary_fp`, which converts an integer holding the bits of a narrow floating-point format such as `Float8E4M3FN` to a native floating-point type. + ### New Compiler Flags - New option `-fdefined-pointer-subtraction` added to preserve stable semantics diff --git a/clang/include/clang/AST/ComputeDependence.h b/clang/include/clang/AST/ComputeDependence.h index 3a3c86842501a..ed843cbe4750b 100644 --- a/clang/include/clang/AST/ComputeDependence.h +++ b/clang/include/clang/AST/ComputeDependence.h @@ -38,6 +38,7 @@ class ConditionalOperator; class BinaryConditionalOperator; class StmtExpr; class ConvertVectorExpr; +class ConvertFromArbitraryFPExpr; class VAArgExpr; class ChooseExpr; class NoInitExpr; @@ -129,6 +130,7 @@ ExprDependence computeDependence(ConditionalOperator *E); ExprDependence computeDependence(BinaryConditionalOperator *E); ExprDependence computeDependence(StmtExpr *E, unsigned TemplateDepth); ExprDependence computeDependence(ConvertVectorExpr *E); +ExprDependence computeDependence(ConvertFromArbitraryFPExpr *E); ExprDependence computeDependence(VAArgExpr *E); ExprDependence computeDependence(ChooseExpr *E); ExprDependence computeDependence(NoInitExpr *E); diff --git a/clang/include/clang/AST/Expr.h b/clang/include/clang/AST/Expr.h index f95f87cc4e8e0..992fbf76b158d 100644 --- a/clang/include/clang/AST/Expr.h +++ b/clang/include/clang/AST/Expr.h @@ -4842,6 +4842,72 @@ class ConvertVectorExpr final } }; +/// ConvertFromArbitraryFPExpr - Clang builtin function +/// __builtin_convert_from_arbitrary_fp. This AST node provides support for +/// interpreting an integer as the bits of the specified floating-point format +/// and converting it to the destination floating-point type. +class ConvertFromArbitraryFPExpr : public Expr { + enum { SRC, FORMAT, END_EXPR }; + Stmt *SubExprs[END_EXPR]; + TypeSourceInfo *TInfo; + SourceLocation BuiltinLoc, RParenLoc; + + friend class ASTStmtReader; + +public: + ConvertFromArbitraryFPExpr(Expr *SrcExpr, Expr *Format, TypeSourceInfo *TI, + QualType DstType, ExprValueKind VK, + ExprObjectKind OK, SourceLocation BuiltinLoc, + SourceLocation RParenLoc) + : Expr(ConvertFromArbitraryFPExprClass, DstType, VK, OK), TInfo(TI), + BuiltinLoc(BuiltinLoc), RParenLoc(RParenLoc) { + SubExprs[SRC] = SrcExpr; + SubExprs[FORMAT] = Format; + setDependence(computeDependence(this)); + } + + explicit ConvertFromArbitraryFPExpr(EmptyShell Empty) + : Expr(ConvertFromArbitraryFPExprClass, Empty) {} + + /// getSrcExpr - Return the integer expression holding the format bits. + Expr *getSrcExpr() const { return cast<Expr>(SubExprs[SRC]); } + + /// getFormatExpr - Return the expression naming the source format. + Expr *getFormatExpr() const { return cast<Expr>(SubExprs[FORMAT]); } + + /// getFormat - Return the name of the source arbitrary floating-point format. + StringRef getFormat() const { + return cast<StringLiteral>(getFormatExpr()->IgnoreParenImpCasts()) + ->getString(); + } + + /// getTypeSourceInfo - Return the destination type. + TypeSourceInfo *getTypeSourceInfo() const { return TInfo; } + void setTypeSourceInfo(TypeSourceInfo *TI) { TInfo = TI; } + + /// getBuiltinLoc - Return the location of the + /// __builtin_convert_from_arbitrary_fp token. + SourceLocation getBuiltinLoc() const { return BuiltinLoc; } + + /// getRParenLoc - Return the location of final right parenthesis. + SourceLocation getRParenLoc() const { return RParenLoc; } + + SourceLocation getBeginLoc() const LLVM_READONLY { return BuiltinLoc; } + SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; } + + static bool classof(const Stmt *T) { + return T->getStmtClass() == ConvertFromArbitraryFPExprClass; + } + + // Iterators + child_range children() { + return child_range(&SubExprs[0], &SubExprs[0] + END_EXPR); + } + const_child_range children() const { + return const_child_range(&SubExprs[0], &SubExprs[0] + END_EXPR); + } +}; + /// ChooseExpr - GNU builtin-in function __builtin_choose_expr. /// This AST node is similar to the conditional operator (?:) in C, with /// the following exceptions: diff --git a/clang/include/clang/AST/RecursiveASTVisitor.h b/clang/include/clang/AST/RecursiveASTVisitor.h index cdf8a71d54cc9..0cac0b9c1eeb0 100644 --- a/clang/include/clang/AST/RecursiveASTVisitor.h +++ b/clang/include/clang/AST/RecursiveASTVisitor.h @@ -3051,6 +3051,9 @@ DEF_TRAVERSE_STMT(OpenACCAsteriskSizeExpr, {}) DEF_TRAVERSE_STMT(PredefinedExpr, {}) DEF_TRAVERSE_STMT(ShuffleVectorExpr, {}) DEF_TRAVERSE_STMT(ConvertVectorExpr, {}) +DEF_TRAVERSE_STMT(ConvertFromArbitraryFPExpr, { + TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc())); +}) DEF_TRAVERSE_STMT(StmtExpr, {}) DEF_TRAVERSE_STMT(SourceLocExpr, {}) DEF_TRAVERSE_STMT(EmbedExpr, { diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td index 06d559a5c3ce2..8c33f9f8ace88 100644 --- a/clang/include/clang/Basic/Builtins.td +++ b/clang/include/clang/Basic/Builtins.td @@ -1481,6 +1481,12 @@ def ConvertVector : Builtin { let Prototype = "void(...)"; } +def ConvertFromArbitraryFP : Builtin { + let Spellings = ["__builtin_convert_from_arbitrary_fp"]; + let Attributes = [NoThrow, Const, CustomTypeChecking]; + let Prototype = "void(...)"; +} + def MaskedLoad : Builtin { let Spellings = ["__builtin_masked_load"]; let Attributes = [NoThrow, CustomTypeChecking]; diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index d9d0d485f16ac..ee0e540685789 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -11491,6 +11491,28 @@ def err_builtin_non_vector_type : Error< def err_convertvector_incompatible_vector : Error< "first two arguments to __builtin_convertvector must have the same number of elements">; +def err_arbitrary_fp_invalid_format : Error< + "'%0' is not a supported arbitrary floating-point format">; +def err_arbitrary_fp_non_ordinary_string_literal : Error< + "format argument to __builtin_convert_from_arbitrary_fp must be an ordinary " + "string literal">; +def err_arbitrary_fp_int_width : Error< + "%select{argument type %1 must be an integer type|vector element type %1 " + "must be}0 %2 bits wide to match format '%3'">; +def err_arbitrary_fp_sizeless_vector : Error< + "%0 argument to %1 has sizeless vector type; only fixed-length vectors are " + "supported">; +def err_arbitrary_fp_non_fp_type : Error< + "%0 argument to %1 must be a floating-point type or a vector of " + "floating-point types">; +def err_arbitrary_fp_non_int_type : Error< + "%0 argument to %1 must be an integer type or a vector of integer types">; +def err_arbitrary_fp_unsupported_dst_type : Error< + "destination type %0 is not supported by %1">; +def err_arbitrary_fp_incompatible_vector : Error< + "floating-point and integer arguments to %0 must have the same number of " + "elements">; + def err_first_argument_to_cwsc_not_call : Error< "first argument to __builtin_call_with_static_chain must be a non-member call expression">; def err_first_argument_to_cwsc_block_call : Error< diff --git a/clang/include/clang/Basic/StmtNodes.td b/clang/include/clang/Basic/StmtNodes.td index f5fa397c92ef3..d2db9797ab8c7 100644 --- a/clang/include/clang/Basic/StmtNodes.td +++ b/clang/include/clang/Basic/StmtNodes.td @@ -219,6 +219,7 @@ def CUDAKernelCallExpr : StmtNode<CallExpr>; // Clang Extensions. def ShuffleVectorExpr : StmtNode<Expr>; def ConvertVectorExpr : StmtNode<Expr>; +def ConvertFromArbitraryFPExpr : StmtNode<Expr>; def BlockExpr : StmtNode<Expr>; def OpaqueValueExpr : StmtNode<Expr>; def RecoveryExpr : StmtNode<Expr>; diff --git a/clang/include/clang/Basic/TokenKinds.def b/clang/include/clang/Basic/TokenKinds.def index 3d8d42caa39cf..d82cd66b13920 100644 --- a/clang/include/clang/Basic/TokenKinds.def +++ b/clang/include/clang/Basic/TokenKinds.def @@ -669,6 +669,7 @@ ALIAS("_pascal" , __pascal , KEYBORLAND) // Clang Extensions. KEYWORD(__builtin_convertvector , KEYALL) +KEYWORD(__builtin_convert_from_arbitrary_fp, KEYALL) ALIAS("__char16_t" , char16_t , KEYCXX) ALIAS("__char32_t" , char32_t , KEYCXX) KEYWORD(__builtin_bit_cast , KEYALL) diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index d46edeb0d2872..7bbb058a98b53 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -2678,6 +2678,16 @@ class Sema final : public SemaBase { SourceLocation BuiltinLoc, SourceLocation RParenLoc); + /// ConvertFromArbitraryFPExpr - Handle __builtin_convert_from_arbitrary_fp + ExprResult ConvertFromArbitraryFPExpr(Expr *E, Expr *Format, + TypeSourceInfo *TInfo, + SourceLocation BuiltinLoc, + SourceLocation RParenLoc); + + /// Check that \p E is an ordinary string literal naming an arbitrary + /// floating-point format. Returns the literal, or null after diagnosing. + const StringLiteral *CheckArbitraryFPFormatArg(Expr *E); + static StringRef GetFormatStringTypeName(FormatStringType FST); static FormatStringType GetFormatStringType(StringRef FormatFlavor); static FormatStringType GetFormatStringType(const FormatAttr *Format); @@ -7722,6 +7732,16 @@ class Sema final : public SemaBase { SourceLocation BuiltinLoc, SourceLocation RParenLoc); + /// ActOnConvertFromArbitraryFPExpr - create a new convert-from-arbitrary-fp + /// expression from the provided arguments. + /// + /// __builtin_convert_from_arbitrary_fp( value, format, dst type ) + /// + ExprResult ActOnConvertFromArbitraryFPExpr(Expr *E, Expr *Format, + ParsedType ParsedDestTy, + SourceLocation BuiltinLoc, + SourceLocation RParenLoc); + //===---------------------------- OpenCL Features -----------------------===// /// Parse a __builtin_astype expression. diff --git a/clang/include/clang/Serialization/ASTBitCodes.h b/clang/include/clang/Serialization/ASTBitCodes.h index 671341488278e..dda950cefc857 100644 --- a/clang/include/clang/Serialization/ASTBitCodes.h +++ b/clang/include/clang/Serialization/ASTBitCodes.h @@ -1759,6 +1759,9 @@ enum StmtCode { /// A ConvertVectorExpr record. EXPR_CONVERT_VECTOR, + /// A ConvertFromArbitraryFPExpr record. + EXPR_CONVERT_FROM_ARBITRARY_FP, + /// BlockExpr EXPR_BLOCK, diff --git a/clang/lib/AST/ASTImporter.cpp b/clang/lib/AST/ASTImporter.cpp index 3ad71a223903c..122a2656d26d7 100644 --- a/clang/lib/AST/ASTImporter.cpp +++ b/clang/lib/AST/ASTImporter.cpp @@ -629,6 +629,7 @@ namespace clang { ExpectedStmt VisitVAArgExpr(VAArgExpr *E); ExpectedStmt VisitChooseExpr(ChooseExpr *E); ExpectedStmt VisitConvertVectorExpr(ConvertVectorExpr *E); + ExpectedStmt VisitConvertFromArbitraryFPExpr(ConvertFromArbitraryFPExpr *E); ExpectedStmt VisitShuffleVectorExpr(ShuffleVectorExpr *E); ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E); ExpectedStmt VisitGenericSelectionExpr(GenericSelectionExpr *E); @@ -7820,6 +7821,23 @@ ExpectedStmt ASTNodeImporter::VisitConvertVectorExpr(ConvertVectorExpr *E) { E->getStoredFPFeaturesOrDefault()); } +ExpectedStmt ASTNodeImporter::VisitConvertFromArbitraryFPExpr( + ConvertFromArbitraryFPExpr *E) { + Error Err = Error::success(); + auto *ToSrcExpr = importChecked(Err, E->getSrcExpr()); + auto *ToFormatExpr = importChecked(Err, E->getFormatExpr()); + auto ToRParenLoc = importChecked(Err, E->getRParenLoc()); + auto ToBuiltinLoc = importChecked(Err, E->getBuiltinLoc()); + auto ToType = importChecked(Err, E->getType()); + auto *ToTSI = importChecked(Err, E->getTypeSourceInfo()); + if (Err) + return std::move(Err); + + return new (Importer.getToContext()) ConvertFromArbitraryFPExpr( + ToSrcExpr, ToFormatExpr, ToTSI, ToType, E->getValueKind(), + E->getObjectKind(), ToBuiltinLoc, ToRParenLoc); +} + ExpectedStmt ASTNodeImporter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { Error Err = Error::success(); auto ToRParenLoc = importChecked(Err, E->getRParenLoc()); diff --git a/clang/lib/AST/ComputeDependence.cpp b/clang/lib/AST/ComputeDependence.cpp index a819bb6dec599..e028d80302c4c 100644 --- a/clang/lib/AST/ComputeDependence.cpp +++ b/clang/lib/AST/ComputeDependence.cpp @@ -201,6 +201,15 @@ ExprDependence clang::computeDependence(ConvertVectorExpr *E) { return D; } +ExprDependence clang::computeDependence(ConvertFromArbitraryFPExpr *E) { + auto D = toExprDependenceAsWritten( + E->getTypeSourceInfo()->getType()->getDependence()) | + E->getSrcExpr()->getDependence(); + if (!E->getType()->isDependentType()) + D &= ~ExprDependence::Type; + return D; +} + ExprDependence clang::computeDependence(ChooseExpr *E) { if (E->isConditionDependent()) return ExprDependence::TypeValueInstantiation | diff --git a/clang/lib/AST/Expr.cpp b/clang/lib/AST/Expr.cpp index 9a9a76e265f6a..a586480dc5cbb 100644 --- a/clang/lib/AST/Expr.cpp +++ b/clang/lib/AST/Expr.cpp @@ -3846,6 +3846,7 @@ bool Expr::HasSideEffects(const ASTContext &Ctx, case MaterializeTemporaryExprClass: case ShuffleVectorExprClass: case ConvertVectorExprClass: + case ConvertFromArbitraryFPExprClass: case AsTypeExprClass: case CXXParenListInitExprClass: // These have a side-effect if any subexpression does. diff --git a/clang/lib/AST/ExprClassification.cpp b/clang/lib/AST/ExprClassification.cpp index ef071cdef66b6..c9ac4dac810e5 100644 --- a/clang/lib/AST/ExprClassification.cpp +++ b/clang/lib/AST/ExprClassification.cpp @@ -182,6 +182,7 @@ static Cl::Kinds ClassifyInternal(ASTContext &Ctx, const Expr *E) { case Expr::CXXThrowExprClass: case Expr::ShuffleVectorExprClass: case Expr::ConvertVectorExprClass: + case Expr::ConvertFromArbitraryFPExprClass: case Expr::IntegerLiteralClass: case Expr::FixedPointLiteralClass: case Expr::CharacterLiteralClass: diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp index a3385d3b7318f..9ba5bcded84e4 100644 --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -22354,6 +22354,7 @@ static ICEDiag CheckICE(const Expr* E, const ASTContext &Ctx) { case Expr::ObjCAvailabilityCheckExprClass: case Expr::ShuffleVectorExprClass: case Expr::ConvertVectorExprClass: + case Expr::ConvertFromArbitraryFPExprClass: case Expr::BlockExprClass: case Expr::NoStmtClass: case Expr::OpaqueValueExprClass: diff --git a/clang/lib/AST/ItaniumMangle.cpp b/clang/lib/AST/ItaniumMangle.cpp index f8e6b898be250..263ff66aba332 100644 --- a/clang/lib/AST/ItaniumMangle.cpp +++ b/clang/lib/AST/ItaniumMangle.cpp @@ -5968,6 +5968,17 @@ void CXXNameMangler::mangleExpression(const Expr *E, unsigned Arity, Out << "v18co_yield"; mangleExpression(cast<CoawaitExpr>(E)->getOperand()); break; + + case Expr::ConvertFromArbitraryFPExprClass: { + const auto *CE = cast<ConvertFromArbitraryFPExpr>(E); + NotPrimaryExpr(); + mangleVendorType("__builtin_convert_from_arbitrary_fp"); + mangleTemplateArgExpr(CE->getSrcExpr()); + mangleVendorType(CE->getFormat()); + mangleType(CE->getTypeSourceInfo()->getType()); + Out << 'E'; + break; + } case Expr::SYCLUniqueStableNameExprClass: { const auto *USN = cast<SYCLUniqueStableNameExpr>(E); NotPrimaryExpr(); diff --git a/clang/lib/AST/StmtPrinter.cpp b/clang/lib/AST/StmtPrinter.cpp index 877191d456b35..57866934df997 100644 --- a/clang/lib/AST/StmtPrinter.cpp +++ b/clang/lib/AST/StmtPrinter.cpp @@ -1995,6 +1995,17 @@ void StmtPrinter::VisitConvertVectorExpr(ConvertVectorExpr *Node) { OS << ")"; } +void StmtPrinter::VisitConvertFromArbitraryFPExpr( + ConvertFromArbitraryFPExpr *Node) { + OS << "__builtin_convert_from_arbitrary_fp("; + PrintExpr(Node->getSrcExpr()); + OS << ", "; + PrintExpr(Node->getFormatExpr()); + OS << ", "; + Node->getTypeSourceInfo()->getType().print(OS, Policy); + OS << ")"; +} + void StmtPrinter::VisitInitListExpr(InitListExpr* Node) { if (Node->getSyntacticForm()) { Visit(Node->getSyntacticForm()); diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp index 00c132f1ed9e... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/212647 _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
