diff options
Diffstat (limited to 'clang')
89 files changed, 8393 insertions, 782 deletions
diff --git a/clang/docs/LanguageExtensions.rst b/clang/docs/LanguageExtensions.rst index 495f2ab..baa0bbb 100644 --- a/clang/docs/LanguageExtensions.rst +++ b/clang/docs/LanguageExtensions.rst @@ -385,7 +385,9 @@ Builtin Macros ``__COUNTER__`` Defined to an integer value that starts at zero and is incremented each time - the ``__COUNTER__`` macro is expanded. + the ``__COUNTER__`` macro is expanded. This is a standard feature in C2y but + is an extension in earlier language modes and in C++. This macro can only be + expanded 2147483647 times at most. ``__INCLUDE_LEVEL__`` Defined to an integral value that is the include depth of the file currently @@ -1821,6 +1823,7 @@ Octal literals prefixed with ``0o`` or ``0O`` C ``_Countof`` (N3369, N3469) C2y C89 ``_Generic`` with a type operand (N3260) C2y C89, C++ ``++``/``--`` on ``_Complex`` value (N3259) C2y C89, C++ +``__COUNTER__`` (N3457) C2y C89, C++ ============================================= ================================ ============= ============= Builtin type aliases diff --git a/clang/docs/ReleaseNotes.rst b/clang/docs/ReleaseNotes.rst index 92fc938..2e2c519 100644 --- a/clang/docs/ReleaseNotes.rst +++ b/clang/docs/ReleaseNotes.rst @@ -196,6 +196,11 @@ C2y Feature Support function or variable within an extern inline function is no longer a constraint per `WG14 N3622 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3622.txt>`_. - Clang now supports `N3355 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3355.htm>`_ Named Loops. +- Clang's implementation of ``__COUNTER__`` was updated to conform to + `WG14 N3457 <https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3457.htm>`_. + This includes adding pedantic warnings for the feature being an extension in + other language modes as well as an error when the counter is expanded more + than 2147483647 times. C23 Feature Support ^^^^^^^^^^^^^^^^^^^ @@ -350,7 +355,7 @@ Improvements to Clang's diagnostics potential misaligned members get processed before they can get discarded. (#GH144729) -- Clang now emits dignostic with correct message in case of assigning to const reference captured in lambda. (#GH105647) +- Clang now emits a diagnostic with the correct message in case of assigning to const reference captured in lambda. (#GH105647) - Fixed false positive in ``-Wmissing-noreturn`` diagnostic when it was requiring the usage of ``[[noreturn]]`` on lambdas before C++23 (#GH154493). @@ -390,6 +395,11 @@ Improvements to Clang's diagnostics that were previously incorrectly accepted in case of other irrelevant conditions are now consistently diagnosed, identical to C++ mode. +- Fix false-positive unused label diagnostic when a label is used in a named break + or continue (#GH166013) +- Clang now emits a diagnostic in case `vector_size` or `ext_vector_type` + attributes are used with a negative size (#GH165463). + Improvements to Clang's time-trace ---------------------------------- @@ -452,6 +462,7 @@ Bug Fixes to Attribute Support - Fix a crash when the function name is empty in the `swift_name` attribute. (#GH157075) - Fixes crashes or missing diagnostics with the `device_kernel` attribute. (#GH161905) - Fix handling of parameter indexes when an attribute is applied to a C++23 explicit object member function. +- Fixed several false positives and false negatives in function effect (`nonblocking`) analysis. (#GH166078) (#GH166101) (#GH166110) Bug Fixes to C++ Support ^^^^^^^^^^^^^^^^^^^^^^^^ @@ -466,7 +477,7 @@ Bug Fixes to C++ Support casts that are guaranteed to fail (#GH137518). - Fix bug rejecting partial specialization of variable templates with auto NTTPs (#GH118190). - Fix a crash if errors "member of anonymous [...] redeclares" and - "intializing multiple members of union" coincide (#GH149985). + "initializing multiple members of union" coincide (#GH149985). - Fix a crash when using ``explicit(bool)`` in pre-C++11 language modes. (#GH152729) - Fix the parsing of variadic member functions when the ellipis immediately follows a default argument.(#GH153445) - Fixed a bug that caused ``this`` captured by value in a lambda with a dependent explicit object parameter to not be @@ -496,6 +507,7 @@ Bug Fixes to C++ Support nontrivial member when another member has an initializer. (#GH81774) - Fixed a template depth issue when parsing lambdas inside a type constraint. (#GH162092) - Diagnose unresolved overload sets in non-dependent compound requirements. (#GH51246) (#GH97753) +- Fix a crash when extracting unavailable member type from alias in template deduction. (#GH165560) Bug Fixes to AST Handling ^^^^^^^^^^^^^^^^^^^^^^^^^ diff --git a/clang/include/clang/AST/APNumericStorage.h b/clang/include/clang/AST/APNumericStorage.h index e1948a5..0442408 100644 --- a/clang/include/clang/AST/APNumericStorage.h +++ b/clang/include/clang/AST/APNumericStorage.h @@ -41,9 +41,8 @@ protected: llvm::APInt getIntValue() const { unsigned NumWords = llvm::APInt::getNumWords(BitWidth); if (NumWords > 1) - return llvm::APInt(BitWidth, NumWords, pVal); - else - return llvm::APInt(BitWidth, VAL); + return llvm::APInt(BitWidth, llvm::ArrayRef(pVal, NumWords)); + return llvm::APInt(BitWidth, VAL); } void setIntValue(const ASTContext &C, const llvm::APInt &Val); }; diff --git a/clang/include/clang/AST/AbstractBasicReader.h b/clang/include/clang/AST/AbstractBasicReader.h index 0d187eb4..064a342 100644 --- a/clang/include/clang/AST/AbstractBasicReader.h +++ b/clang/include/clang/AST/AbstractBasicReader.h @@ -173,7 +173,7 @@ public: llvm::SmallVector<uint64_t, 4> data; for (uint32_t i = 0; i != numWords; ++i) data.push_back(asImpl().readUInt64()); - return llvm::APInt(bitWidth, numWords, &data[0]); + return llvm::APInt(bitWidth, data); } llvm::FixedPointSemantics readFixedPointSemantics() { diff --git a/clang/include/clang/Basic/DebugOptions.def b/clang/include/clang/Basic/DebugOptions.def index a768b12..ea3636f 100644 --- a/clang/include/clang/Basic/DebugOptions.def +++ b/clang/include/clang/Basic/DebugOptions.def @@ -46,6 +46,8 @@ ENUM_DEBUGOPT(EmitDwarfUnwind, EmitDwarfUnwindType, 2, DEBUGOPT(NoDwarfDirectoryAsm , 1, 0, Benign) ///< Set when -fno-dwarf-directory-asm ///< is enabled. +DEBUGOPT(Dwarf2CFIAsm, 1, 0, NotCompatible) ///< Set when -fdwarf2-cfi-asm is enabled. + DEBUGOPT(NoInlineLineTables, 1, 0, Benign) ///< Whether debug info should contain ///< inline line tables. diff --git a/clang/include/clang/Basic/DiagnosticLexKinds.td b/clang/include/clang/Basic/DiagnosticLexKinds.td index c7fe6e1d..4171872 100644 --- a/clang/include/clang/Basic/DiagnosticLexKinds.td +++ b/clang/include/clang/Basic/DiagnosticLexKinds.td @@ -90,6 +90,14 @@ def err_unterminated___pragma : Error<"missing terminating ')' character">; def err_conflict_marker : Error<"version control conflict marker in file">; +def err_counter_overflow : Error< + "'__COUNTER__' value cannot exceed 2'147'483'647">; +def ext_counter : Extension< + "'__COUNTER__' is a C2y extension">, InGroup<C2y>; +def warn_counter : Warning< + "'__COUNTER__' is incompatible with standards before C2y">, + InGroup<CPre2yCompat>, DefaultIgnore; + def err_raw_delim_too_long : Error< "raw string delimiter longer than 16 characters" "; use PREFIX( )PREFIX to delimit raw string">; diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 4e369be..fa50953 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -3510,6 +3510,8 @@ def err_init_method_bad_return_type : Error< "init methods must return an object pointer type, not %0">; def err_attribute_invalid_size : Error< "vector size not an integral multiple of component size">; +def err_attribute_vec_negative_size + : Error<"vector must have non-negative size">; def err_attribute_zero_size : Error<"zero %0 size">; def err_attribute_size_too_large : Error<"%0 size too large">; def err_typecheck_sve_rvv_ambiguous : Error< diff --git a/clang/include/clang/Basic/riscv_sifive_vector.td b/clang/include/clang/Basic/riscv_sifive_vector.td index 89e644a..0371279 100644 --- a/clang/include/clang/Basic/riscv_sifive_vector.td +++ b/clang/include/clang/Basic/riscv_sifive_vector.td @@ -121,6 +121,13 @@ multiclass RVVVQMACCQOQBuiltinSet<list<list<string>> suffixes_prototypes> { defm NAME : RVVOutOp1Op2BuiltinSet<NAME, "s", suffixes_prototypes>; } +multiclass RVVVFEXPBuiltinSet<list<list<string>> suffixes_prototypes, string type_range> { + let UnMaskedPolicyScheme = HasPassthruOperand, + OverloadedName = NAME, + Log2LMUL = [-2, -1, 0, 1, 2, 3] in + defm NAME : RVVOutBuiltinSet<NAME, type_range, suffixes_prototypes>; +} + multiclass RVVVFNRCLIPBuiltinSet<string suffix, string prototype, string type_range> { let Log2LMUL = [-3, -2, -1, 0, 1, 2], Name = NAME, @@ -145,6 +152,26 @@ let UnMaskedPolicyScheme = HasPolicyOperand in defm sf_vqmaccsu_4x8x4 : RVVVQMACCQOQBuiltinSet<[["", "w", "ww(FixedSEW:8)Sv(FixedSEW:8)Uv"]]>; } +let RequiredFeatures = ["xsfvfbfexp16e"] in { + defm sf_vfexp : RVVVFEXPBuiltinSet<[["v", "v", "vv"]], "y">; +} + +let RequiredFeatures = ["xsfvfexp16e"] in { + defm sf_vfexp : RVVVFEXPBuiltinSet<[["v", "v", "vv"]], "x">; +} + +let RequiredFeatures = ["xsfvfexp32e"] in { + defm sf_vfexp : RVVVFEXPBuiltinSet<[["v", "v", "vv"]], "f">; +} + +let RequiredFeatures = ["xsfvfexpa"] in { + defm sf_vfexpa : RVVVFEXPBuiltinSet<[["v", "v", "vv"]], "xf">; +} + +let RequiredFeatures = ["xsfvfexpa64e"] in { + defm sf_vfexpa : RVVVFEXPBuiltinSet<[["v", "v", "vv"]], "d">; +} + let UnMaskedPolicyScheme = HasPolicyOperand in let RequiredFeatures = ["xsfvfwmaccqqq"] in defm sf_vfwmacc_4x4x4 : RVVVFWMACCBuiltinSet<[["", "Fw", "FwFwSvv"]]>; diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td index 2b361ed..dc56db1 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIROps.td +++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td @@ -4171,6 +4171,16 @@ def CIR_ATanOp : CIR_UnaryFPToFPBuiltinOp<"atan", "ATanOp"> { }]; } +def CIR_CeilOp : CIR_UnaryFPToFPBuiltinOp<"ceil", "FCeilOp"> { + let summary = "Computes the ceiling of the specified value"; + let description = [{ + `cir.ceil` computes the ceiling of a given value and returns a result + of the same type. + + Floating-point exceptions are ignored, and it does not set `errno`. + }]; +} + def CIR_CosOp : CIR_UnaryFPToFPBuiltinOp<"cos", "CosOp"> { let summary = "Computes the floating-point cosine value"; let description = [{ diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 6e1c942..11e81e0 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -741,6 +741,7 @@ def gcc_toolchain : Joined<["--"], "gcc-toolchain=">, Flags<[NoXarchOption]>, "Specify a directory where Flang can find 'lib{,32,64}/gcc{,-cross}/$triple/$version'. " "Flang will use the GCC installation with the largest version">; def gcc_triple_EQ : Joined<["--"], "gcc-triple=">, + Visibility<[ClangOption, FlangOption]>, HelpText<"Search for the GCC installation with the specified triple.">; def CC : Flag<["-"], "CC">, Visibility<[ClangOption, CC1Option]>, Group<Preprocessor_Group>, @@ -950,9 +951,9 @@ def Xarch__ the host system, which can be used to suppress incompatible GPU arguments.}]>, MetaVarName<"<arch> <arg>">; def Xarch_host : Separate<["-"], "Xarch_host">, Flags<[NoXarchOption]>, - HelpText<"Pass <arg> to the CUDA/HIP host compilation">, MetaVarName<"<arg>">; + HelpText<"Pass <arg> to host compilation in the offloading toolchain">, MetaVarName<"<arg>">; def Xarch_device : Separate<["-"], "Xarch_device">, Flags<[NoXarchOption]>, - HelpText<"Pass <arg> to the CUDA/HIP device compilation">, MetaVarName<"<arg>">; + HelpText<"Pass <arg> to device compilation in the offloading toolchain">, MetaVarName<"<arg>">; def Xassembler : Separate<["-"], "Xassembler">, HelpText<"Pass <arg> to the assembler">, MetaVarName<"<arg>">, Group<CompileOnly_Group>; @@ -2154,8 +2155,12 @@ defm dollars_in_identifiers : BoolFOption<"dollars-in-identifiers", PosFlag<SetTrue, [], [ClangOption], "Allow">, NegFlag<SetFalse, [], [ClangOption], "Disallow">, BothFlags<[], [ClangOption, CC1Option], " '$' in identifiers">>; -def fdwarf2_cfi_asm : Flag<["-"], "fdwarf2-cfi-asm">, Group<clang_ignored_f_Group>; -def fno_dwarf2_cfi_asm : Flag<["-"], "fno-dwarf2-cfi-asm">, Group<clang_ignored_f_Group>; + +defm dwarf2_cfi_asm + : BoolFOption<"dwarf2-cfi-asm", CodeGenOpts<"Dwarf2CFIAsm">, DefaultFalse, + PosFlag<SetTrue, [], [ClangOption, CC1Option]>, + NegFlag<SetFalse>>; + defm dwarf_directory_asm : BoolFOption<"dwarf-directory-asm", CodeGenOpts<"NoDwarfDirectoryAsm">, DefaultFalse, NegFlag<SetTrue, [], [ClangOption, CC1Option]>, @@ -8445,6 +8450,10 @@ def aligned_alloc_unavailable : Flag<["-"], "faligned-alloc-unavailable">, MarshallingInfoFlag<LangOpts<"AlignedAllocationUnavailable">>, ShouldParseIf<faligned_allocation.KeyPath>; +def finitial_counter_value_EQ : Joined<["-"], "finitial-counter-value=">, + HelpText<"Sets the initial value for __COUNTER__, defaults to 0.">, + MarshallingInfoInt<PreprocessorOpts<"InitialCounterValue">, "0">; + } // let Visibility = [CC1Option] //===----------------------------------------------------------------------===// diff --git a/clang/include/clang/Lex/Preprocessor.h b/clang/include/clang/Lex/Preprocessor.h index 3975484..4120022 100644 --- a/clang/include/clang/Lex/Preprocessor.h +++ b/clang/include/clang/Lex/Preprocessor.h @@ -226,7 +226,7 @@ class Preprocessor { LangOptions::FPEvalMethodKind::FEM_UnsetOnCommandLine; // Next __COUNTER__ value, starts at 0. - unsigned CounterValue = 0; + uint32_t CounterValue = 0; enum { /// Maximum depth of \#includes. @@ -2421,8 +2421,8 @@ public: bool SawDateOrTime() const { return DATELoc != SourceLocation() || TIMELoc != SourceLocation(); } - unsigned getCounterValue() const { return CounterValue; } - void setCounterValue(unsigned V) { CounterValue = V; } + uint32_t getCounterValue() const { return CounterValue; } + void setCounterValue(uint32_t V) { CounterValue = V; } LangOptions::FPEvalMethodKind getCurrentFPEvalMethod() const { assert(CurrentFPEvalMethod != LangOptions::FEM_UnsetOnCommandLine && diff --git a/clang/include/clang/Lex/PreprocessorOptions.h b/clang/include/clang/Lex/PreprocessorOptions.h index d4c4e1c..1c2f6e7 100644 --- a/clang/include/clang/Lex/PreprocessorOptions.h +++ b/clang/include/clang/Lex/PreprocessorOptions.h @@ -198,6 +198,10 @@ public: /// If set, the UNIX timestamp specified by SOURCE_DATE_EPOCH. std::optional<uint64_t> SourceDateEpoch; + /// The initial value for __COUNTER__; typically is zero but can be set via a + /// -cc1 flag for testing purposes. + uint32_t InitialCounterValue = 0; + public: PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {} diff --git a/clang/include/clang/Serialization/ASTReader.h b/clang/include/clang/Serialization/ASTReader.h index af856a80..4ca45a1 100644 --- a/clang/include/clang/Serialization/ASTReader.h +++ b/clang/include/clang/Serialization/ASTReader.h @@ -220,8 +220,8 @@ public: } /// Receives __COUNTER__ value. - virtual void ReadCounter(const serialization::ModuleFile &M, - unsigned Value) {} + virtual void ReadCounter(const serialization::ModuleFile &M, uint32_t Value) { + } /// This is called for each AST file loaded. virtual void visitModuleFile(StringRef Filename, @@ -312,7 +312,7 @@ public: bool Complain, std::string &SuggestedPredefines) override; - void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override; + void ReadCounter(const serialization::ModuleFile &M, uint32_t Value) override; bool needsInputFileVisitation() override; bool needsSystemInputFileVisitation() override; void visitModuleFile(StringRef Filename, @@ -352,7 +352,7 @@ public: StringRef ModuleFilename, StringRef SpecificModuleCachePath, bool Complain) override; - void ReadCounter(const serialization::ModuleFile &M, unsigned Value) override; + void ReadCounter(const serialization::ModuleFile &M, uint32_t Value) override; }; /// ASTReaderListenter implementation to set SuggestedPredefines of diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h index 4aee165..66da799 100644 --- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h +++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h @@ -372,12 +372,10 @@ public: ProgramPoint getProgramPoint(bool IsPreVisit = false, const ProgramPointTag *Tag = nullptr) const; - /// Returns a new state with all argument regions invalidated. - /// - /// This accepts an alternate state in case some processing has already - /// occurred. + /// Invalidates the regions (arguments, globals, special regions like 'this') + /// that may have been written by this call, returning the updated state. ProgramStateRef invalidateRegions(unsigned BlockCount, - ProgramStateRef Orig = nullptr) const; + ProgramStateRef State) const; using FrameBindingTy = std::pair<SVal, SVal>; using BindingsTy = SmallVectorImpl<FrameBindingTy>; diff --git a/clang/lib/AST/ByteCode/Floating.h b/clang/lib/AST/ByteCode/Floating.h index 659892e..cc918dc 100644 --- a/clang/lib/AST/ByteCode/Floating.h +++ b/clang/lib/AST/ByteCode/Floating.h @@ -45,7 +45,8 @@ private: if (singleWord()) return APFloat(getSemantics(), APInt(BitWidth, Val)); unsigned NumWords = numWords(); - return APFloat(getSemantics(), APInt(BitWidth, NumWords, Memory)); + return APFloat(getSemantics(), + APInt(BitWidth, llvm::ArrayRef(Memory, NumWords))); } public: diff --git a/clang/lib/AST/ByteCode/IntegralAP.h b/clang/lib/AST/ByteCode/IntegralAP.h index 6683db9..b11e6ee 100644 --- a/clang/lib/AST/ByteCode/IntegralAP.h +++ b/clang/lib/AST/ByteCode/IntegralAP.h @@ -63,7 +63,7 @@ public: if (singleWord()) return APInt(BitWidth, Val, Signed); unsigned NumWords = llvm::APInt::getNumWords(BitWidth); - return llvm::APInt(BitWidth, NumWords, Memory); + return llvm::APInt(BitWidth, llvm::ArrayRef(Memory, NumWords)); } public: diff --git a/clang/lib/Analysis/ExprMutationAnalyzer.cpp b/clang/lib/Analysis/ExprMutationAnalyzer.cpp index 75b17c54..54c30c0 100644 --- a/clang/lib/Analysis/ExprMutationAnalyzer.cpp +++ b/clang/lib/Analysis/ExprMutationAnalyzer.cpp @@ -746,11 +746,14 @@ ExprMutationAnalyzer::Analyzer::findPointeeMemberMutation(const Expr *Exp) { Stm, Context)); if (MemberCallExpr) return MemberCallExpr; - const auto Matches = - match(stmt(forEachDescendant( - memberExpr(hasObjectExpression(canResolveToExprPointee(Exp))) - .bind(NodeID<Expr>::value))), - Stm, Context); + const auto Matches = match( + stmt(forEachDescendant( + expr(anyOf(memberExpr( + hasObjectExpression(canResolveToExprPointee(Exp))), + binaryOperator(hasOperatorName("->*"), + hasLHS(canResolveToExprPointee(Exp))))) + .bind(NodeID<Expr>::value))), + Stm, Context); return findExprMutation(Matches); } diff --git a/clang/lib/Basic/SourceManager.cpp b/clang/lib/Basic/SourceManager.cpp index 938c648..97aa0f2 100644 --- a/clang/lib/Basic/SourceManager.cpp +++ b/clang/lib/Basic/SourceManager.cpp @@ -907,19 +907,23 @@ getExpansionLocSlowCase(SourceLocation Loc) const { SourceLocation SourceManager::getSpellingLocSlowCase(SourceLocation Loc) const { do { - FileIDAndOffset LocInfo = getDecomposedLoc(Loc); - Loc = getSLocEntry(LocInfo.first).getExpansion().getSpellingLoc(); - Loc = Loc.getLocWithOffset(LocInfo.second); + const SLocEntry &Entry = getSLocEntry(getFileID(Loc)); + Loc = Entry.getExpansion().getSpellingLoc().getLocWithOffset( + Loc.getOffset() - Entry.getOffset()); } while (!Loc.isFileID()); return Loc; } SourceLocation SourceManager::getFileLocSlowCase(SourceLocation Loc) const { do { - if (isMacroArgExpansion(Loc)) - Loc = getImmediateSpellingLoc(Loc); - else - Loc = getImmediateExpansionRange(Loc).getBegin(); + const SLocEntry &Entry = getSLocEntry(getFileID(Loc)); + const ExpansionInfo &ExpInfo = Entry.getExpansion(); + if (ExpInfo.isMacroArgExpansion()) { + Loc = ExpInfo.getSpellingLoc().getLocWithOffset(Loc.getOffset() - + Entry.getOffset()); + } else { + Loc = ExpInfo.getExpansionLocStart(); + } } while (!Loc.isFileID()); return Loc; } diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp index e35100f..d9b9e3b 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp @@ -211,6 +211,17 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl &gd, unsigned builtinID, assert(!cir::MissingFeatures::fastMathFlags()); return emitUnaryMaybeConstrainedFPBuiltin<cir::CosOp>(*this, *e); + case Builtin::BIceil: + case Builtin::BIceilf: + case Builtin::BIceill: + case Builtin::BI__builtin_ceil: + case Builtin::BI__builtin_ceilf: + case Builtin::BI__builtin_ceilf16: + case Builtin::BI__builtin_ceill: + case Builtin::BI__builtin_ceilf128: + assert(!cir::MissingFeatures::fastMathFlags()); + return emitUnaryMaybeConstrainedFPBuiltin<cir::CeilOp>(*this, *e); + case Builtin::BIfabs: case Builtin::BIfabsf: case Builtin::BIfabsl: diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index 5a6193f..d941082 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -1336,6 +1336,14 @@ mlir::LogicalResult CIRToLLVMATanOpLowering::matchAndRewrite( return mlir::success(); } +mlir::LogicalResult CIRToLLVMCeilOpLowering::matchAndRewrite( + cir::CeilOp op, OpAdaptor adaptor, + mlir::ConversionPatternRewriter &rewriter) const { + mlir::Type resTy = typeConverter->convertType(op.getType()); + rewriter.replaceOpWithNewOp<mlir::LLVM::FCeilOp>(op, resTy, adaptor.getSrc()); + return mlir::success(); +} + mlir::LogicalResult CIRToLLVMAllocaOpLowering::matchAndRewrite( cir::AllocaOp op, OpAdaptor adaptor, mlir::ConversionPatternRewriter &rewriter) const { diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index d3ab6f1..30d3e52 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -7879,10 +7879,13 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, !TC.getTriple().isAndroid() && TC.useIntegratedAs())) CmdArgs.push_back("-faddrsig"); - if ((Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) && + const bool HasDefaultDwarf2CFIASM = + (Triple.isOSBinFormatELF() || Triple.isOSBinFormatMachO()) && (EH || UnwindTables || AsyncUnwindTables || - DebugInfoKind != llvm::codegenoptions::NoDebugInfo)) - CmdArgs.push_back("-D__GCC_HAVE_DWARF2_CFI_ASM=1"); + DebugInfoKind != llvm::codegenoptions::NoDebugInfo); + if (Args.hasFlag(options::OPT_fdwarf2_cfi_asm, + options::OPT_fno_dwarf2_cfi_asm, HasDefaultDwarf2CFIASM)) + CmdArgs.push_back("-fdwarf2-cfi-asm"); if (Arg *A = Args.getLastArg(options::OPT_fsymbol_partition_EQ)) { std::string Str = A->getAsString(Args); diff --git a/clang/lib/Format/FormatTokenLexer.cpp b/clang/lib/Format/FormatTokenLexer.cpp index ab32938..a9ea5ec 100644 --- a/clang/lib/Format/FormatTokenLexer.cpp +++ b/clang/lib/Format/FormatTokenLexer.cpp @@ -318,14 +318,21 @@ void FormatTokenLexer::tryMergePreviousTokens() { {tok::equal, tok::greater}, {tok::star, tok::greater}, {tok::pipeequal, tok::greater}, - {tok::pipe, tok::arrow}, - {tok::hash, tok::minus, tok::hash}, - {tok::hash, tok::equal, tok::hash}}, + {tok::pipe, tok::arrow}}, TT_BinaryOperator) || Tokens.back()->is(tok::arrow)) { Tokens.back()->ForcedPrecedence = prec::Comma; return; } + if (Tokens.size() >= 3 && + Tokens[Tokens.size() - 3]->is(Keywords.kw_verilogHash) && + Tokens[Tokens.size() - 2]->isOneOf(tok::minus, tok::equal) && + Tokens[Tokens.size() - 1]->is(Keywords.kw_verilogHash) && + tryMergeTokens(3, TT_BinaryOperator)) { + Tokens.back()->setFinalizedType(TT_BinaryOperator); + Tokens.back()->ForcedPrecedence = prec::Comma; + return; + } } else if (Style.isTableGen()) { // TableGen's Multi line string starts with [{ if (tryMergeTokens({tok::l_square, tok::l_brace}, diff --git a/clang/lib/Format/TokenAnnotator.cpp b/clang/lib/Format/TokenAnnotator.cpp index 8e227da..cb41756c 100644 --- a/clang/lib/Format/TokenAnnotator.cpp +++ b/clang/lib/Format/TokenAnnotator.cpp @@ -358,11 +358,11 @@ private: Contexts.back().IsExpression = false; } else if (OpeningParen.Previous && (OpeningParen.Previous->isOneOf( - tok::kw_static_assert, tok::kw_noexcept, tok::kw_explicit, - tok::kw_while, tok::l_paren, tok::comma, TT_CastRParen, + tok::kw_noexcept, tok::kw_explicit, tok::kw_while, + tok::l_paren, tok::comma, TT_CastRParen, TT_BinaryOperator) || OpeningParen.Previous->isIf())) { - // static_assert, if and while usually contain expressions. + // if and while usually contain expressions. Contexts.back().IsExpression = true; } else if (Style.isJavaScript() && OpeningParen.Previous && (OpeningParen.Previous->is(Keywords.kw_function) || @@ -454,6 +454,11 @@ private: if (StartsObjCSelector) OpeningParen.setType(TT_ObjCSelector); + const bool IsStaticAssert = + PrevNonComment && PrevNonComment->is(tok::kw_static_assert); + if (IsStaticAssert) + Contexts.back().InStaticAssertFirstArgument = true; + // MightBeFunctionType and ProbablyFunctionType are used for // function pointer and reference types as well as Objective-C // block types: @@ -583,8 +588,12 @@ private: } // When we discover a 'new', we set CanBeExpression to 'false' in order to // parse the type correctly. Reset that after a comma. - if (CurrentToken->is(tok::comma)) - Contexts.back().CanBeExpression = true; + if (CurrentToken->is(tok::comma)) { + if (IsStaticAssert) + Contexts.back().InStaticAssertFirstArgument = false; + else + Contexts.back().CanBeExpression = true; + } if (Style.isTableGen()) { if (CurrentToken->is(tok::comma)) { @@ -2144,6 +2153,7 @@ private: bool CaretFound = false; bool InCpp11AttributeSpecifier = false; bool InCSharpAttributeSpecifier = false; + bool InStaticAssertFirstArgument = false; bool VerilogAssignmentFound = false; // Whether the braces may mean concatenation instead of structure or array // literal. @@ -2440,7 +2450,8 @@ private: } else if (Current.isPointerOrReference()) { Current.setType(determineStarAmpUsage( Current, - Contexts.back().CanBeExpression && Contexts.back().IsExpression, + (Contexts.back().CanBeExpression && Contexts.back().IsExpression) || + Contexts.back().InStaticAssertFirstArgument, Contexts.back().ContextType == Context::TemplateArgument)); } else if (Current.isOneOf(tok::minus, tok::plus, tok::caret) || (Style.isVerilog() && Current.is(tok::pipe))) { diff --git a/clang/lib/Format/WhitespaceManager.cpp b/clang/lib/Format/WhitespaceManager.cpp index f24b8ab..406c77c 100644 --- a/clang/lib/Format/WhitespaceManager.cpp +++ b/clang/lib/Format/WhitespaceManager.cpp @@ -591,7 +591,8 @@ static unsigned AlignTokens(const FormatStyle &Style, F &&Matches, CurrentChangeWidthRight = CurrentChange.TokenLength; const FormatToken *MatchingParenToEncounter = nullptr; for (unsigned J = I + 1; - J != E && (Changes[J].NewlinesBefore == 0 || MatchingParenToEncounter); + J != E && (Changes[J].NewlinesBefore == 0 || + MatchingParenToEncounter || Changes[J].IsAligned); ++J) { const auto &Change = Changes[J]; const auto *Tok = Change.Tok; diff --git a/clang/lib/Frontend/ASTUnit.cpp b/clang/lib/Frontend/ASTUnit.cpp index 6cc7094..1169acb 100644 --- a/clang/lib/Frontend/ASTUnit.cpp +++ b/clang/lib/Frontend/ASTUnit.cpp @@ -518,14 +518,14 @@ class ASTInfoCollector : public ASTReaderListener { LangOptions &LangOpts; CodeGenOptions &CodeGenOpts; TargetOptions &TargetOpts; - unsigned &Counter; + uint32_t &Counter; public: ASTInfoCollector(HeaderSearchOptions &HSOpts, std::string &SpecificModuleCachePath, PreprocessorOptions &PPOpts, LangOptions &LangOpts, CodeGenOptions &CodeGenOpts, TargetOptions &TargetOpts, - unsigned &Counter) + uint32_t &Counter) : HSOpts(HSOpts), SpecificModuleCachePath(SpecificModuleCachePath), PPOpts(PPOpts), LangOpts(LangOpts), CodeGenOpts(CodeGenOpts), TargetOpts(TargetOpts), Counter(Counter) {} @@ -577,7 +577,7 @@ public: } void ReadCounter(const serialization::ModuleFile &M, - unsigned NewCounter) override { + uint32_t NewCounter) override { Counter = NewCounter; } }; diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp index 8602be1..b88d9f8 100644 --- a/clang/lib/Frontend/InitPreprocessor.cpp +++ b/clang/lib/Frontend/InitPreprocessor.cpp @@ -1516,6 +1516,9 @@ static void InitializePredefinedMacros(const TargetInfo &TI, if (LangOpts.PointerAuthIntrinsics) Builder.defineMacro("__PTRAUTH__"); + if (CGOpts.Dwarf2CFIAsm) + Builder.defineMacro("__GCC_HAVE_DWARF2_CFI_ASM"); + // Get other target #defines. TI.getTargetDefines(LangOpts, Builder); } @@ -1542,6 +1545,9 @@ void clang::InitializePreprocessor(Preprocessor &PP, llvm::raw_string_ostream Predefines(PredefineBuffer); MacroBuilder Builder(Predefines); + // Ensure that the initial value of __COUNTER__ is hooked up. + PP.setCounterValue(InitOpts.InitialCounterValue); + // Emit line markers for various builtin sections of the file. The 3 here // marks <built-in> as being a system header, which suppresses warnings when // the same macro is defined multiple times. diff --git a/clang/lib/Frontend/TextDiagnostic.cpp b/clang/lib/Frontend/TextDiagnostic.cpp index aea3e72..1003218 100644 --- a/clang/lib/Frontend/TextDiagnostic.cpp +++ b/clang/lib/Frontend/TextDiagnostic.cpp @@ -349,14 +349,13 @@ private: /// When the source code line we want to print is too long for /// the terminal, select the "interesting" region. -static void selectInterestingSourceRegion(std::string &SourceLine, - std::string &CaretLine, - std::string &FixItInsertionLine, - Columns NonGutterColumns, - const SourceColumnMap &Map) { - Columns CaretColumns = Columns(CaretLine.size()); - Columns FixItColumns = - Columns(llvm::sys::locale::columnWidth(FixItInsertionLine)); +static void selectInterestingSourceRegion( + std::string &SourceLine, std::string &CaretLine, + std::string &FixItInsertionLine, Columns NonGutterColumns, + const SourceColumnMap &Map, + SmallVectorImpl<clang::TextDiagnostic::StyleRange> &Styles) { + Columns CaretColumns = CaretLine.size(); + Columns FixItColumns = llvm::sys::locale::columnWidth(FixItInsertionLine); Columns MaxColumns = std::max({Map.columns().V, CaretColumns.V, FixItColumns.V}); // if the number of columns is less than the desired number we're done @@ -369,13 +368,11 @@ static void selectInterestingSourceRegion(std::string &SourceLine, // Find the slice that we need to display the full caret line // correctly. Columns CaretStart = 0, CaretEnd = CaretLine.size(); - for (; CaretStart != CaretEnd; CaretStart = CaretStart.next()) - if (!isWhitespace(CaretLine[CaretStart.V])) - break; + while (CaretStart != CaretEnd && isWhitespace(CaretLine[CaretStart.V])) + CaretStart = CaretStart.next(); - for (; CaretEnd != CaretStart; CaretEnd = CaretEnd.prev()) - if (!isWhitespace(CaretLine[CaretEnd.V - 1])) - break; + while (CaretEnd != CaretStart && isWhitespace(CaretLine[CaretEnd.V])) + CaretEnd = CaretEnd.prev(); // caret has already been inserted into CaretLine so the above whitespace // check is guaranteed to include the caret @@ -516,13 +513,45 @@ static void selectInterestingSourceRegion(std::string &SourceLine, assert(FrontColumnsRemoved + ColumnsKept + BackColumnsRemoved > NonGutterColumns); + // Since we've modified the SourceLine, we also need to adjust the line's + // highlighting information. In particular, if we've removed + // from the front of the line, we need to move the style ranges to the + // left and remove unneeded ranges. + // Note in particular that variables like CaretEnd are defined in the + // CaretLine, which only contains ASCII, while the style ranges are defined in + // the source line, where we have to care for the byte-index != column-index + // case. + Bytes BytesRemoved = + FrontColumnsRemoved > FrontEllipse.size() + ? (Map.columnToByte(FrontColumnsRemoved) - Bytes(FrontEllipse.size())) + : 0; + Bytes CodeEnd = + CaretEnd < Map.columns() ? Map.columnToByte(CaretEnd.V) : CaretEnd.V; + for (TextDiagnostic::StyleRange &R : Styles) { + // Remove style ranges before and after the new truncated snippet. + if (R.Start >= static_cast<unsigned>(CodeEnd.V) || + R.End < static_cast<unsigned>(BytesRemoved.V)) { + R.Start = R.End = std::numeric_limits<int>::max(); + continue; + } + // Move them left. (Note that this can wrap R.Start, but that doesn't + // matter). + R.Start -= BytesRemoved.V; + R.End -= BytesRemoved.V; + + // Don't leak into the ellipse at the end. + if (R.Start < static_cast<unsigned>(CodeEnd.V) && + R.End > static_cast<unsigned>(CodeEnd.V)) + R.End = CodeEnd.V + 1; // R.End is inclusive. + } + // The line needs some truncation, and we'd prefer to keep the front // if possible, so remove the back if (BackColumnsRemoved > Columns(BackEllipse.size())) SourceLine.replace(SourceEnd.V, std::string::npos, BackEllipse); // If that's enough then we're done - if (FrontColumnsRemoved + ColumnsKept <= Columns(NonGutterColumns)) + if (FrontColumnsRemoved + ColumnsKept <= NonGutterColumns) return; // Otherwise remove the front as well @@ -1391,6 +1420,11 @@ void TextDiagnostic::emitSnippetAndCaret( OS.indent(MaxLineNoDisplayWidth + 2) << "| "; }; + Columns MessageLength = DiagOpts.MessageLength; + // If we don't have enough columns available, just abort now. + if (MessageLength != 0 && MessageLength <= Columns(MaxLineNoDisplayWidth + 4)) + return; + // Prepare source highlighting information for the lines we're about to // emit, starting from the first line. std::unique_ptr<SmallVector<StyleRange>[]> SourceStyles = @@ -1450,10 +1484,14 @@ void TextDiagnostic::emitSnippetAndCaret( // If the source line is too long for our terminal, select only the // "interesting" source region within that line. - Columns MessageLength = DiagOpts.MessageLength; - if (MessageLength.V != 0) + if (MessageLength != 0) { + Columns NonGutterColumns = MessageLength; + if (MaxLineNoDisplayWidth != 0) + NonGutterColumns -= Columns(MaxLineNoDisplayWidth + 4); selectInterestingSourceRegion(SourceLine, CaretLine, FixItInsertionLine, - MessageLength, SourceColMap); + NonGutterColumns, SourceColMap, + SourceStyles[LineNo - Lines.first]); + } // If we are in -fdiagnostics-print-source-range-info mode, we are trying // to produce easily machine parsable output. Add a space before the @@ -1508,7 +1546,7 @@ void TextDiagnostic::emitSnippet(StringRef SourceLine, // Print the source line one character at a time. bool PrintReversed = false; std::optional<llvm::raw_ostream::Colors> CurrentColor; - size_t I = 0; + size_t I = 0; // Bytes. while (I < SourceLine.size()) { auto [Str, WasPrintable] = printableTextForNextCharacter(SourceLine, &I, DiagOpts.TabStop); diff --git a/clang/lib/Headers/module.modulemap b/clang/lib/Headers/module.modulemap index 2e4d533..c13dd3f 100644 --- a/clang/lib/Headers/module.modulemap +++ b/clang/lib/Headers/module.modulemap @@ -253,6 +253,11 @@ module _Builtin_stdbool [system] { export * } +module _Builtin_stdckdint [system] { + header "stdckdint.h" + export * +} + module _Builtin_stdcountof [system] { header "stdcountof.h" export * diff --git a/clang/lib/Lex/ModuleMap.cpp b/clang/lib/Lex/ModuleMap.cpp index 637a08f..b8202ea 100644 --- a/clang/lib/Lex/ModuleMap.cpp +++ b/clang/lib/Lex/ModuleMap.cpp @@ -258,6 +258,7 @@ static bool isBuiltinHeaderName(StringRef FileName) { .Case("stdarg.h", true) .Case("stdatomic.h", true) .Case("stdbool.h", true) + .Case("stdckdint.h", true) .Case("stdcountof.h", true) .Case("stddef.h", true) .Case("stdint.h", true) diff --git a/clang/lib/Lex/PPMacroExpansion.cpp b/clang/lib/Lex/PPMacroExpansion.cpp index dd80ae5..5efa4b5 100644 --- a/clang/lib/Lex/PPMacroExpansion.cpp +++ b/clang/lib/Lex/PPMacroExpansion.cpp @@ -1735,7 +1735,19 @@ void Preprocessor::ExpandBuiltinMacro(Token &Tok) { Diag(getLastFPEvalPragmaLocation(), diag::note_pragma_entered_here); } } else if (II == Ident__COUNTER__) { - // __COUNTER__ expands to a simple numeric value. + Diag(Tok.getLocation(), + getLangOpts().C2y ? diag::warn_counter : diag::ext_counter); + // __COUNTER__ expands to a simple numeric value that must be less than + // 2147483647. + constexpr uint32_t MaxPosValue = std::numeric_limits<int32_t>::max(); + if (CounterValue > MaxPosValue) { + Diag(Tok.getLocation(), diag::err_counter_overflow); + // Retain the maximal value so we don't issue conversion-related + // diagnostics by overflowing into a long long. While this does produce + // a duplicate value, there's no way to ignore this error so there's no + // translation anyway. + CounterValue = MaxPosValue; + } OS << CounterValue++; Tok.setKind(tok::numeric_constant); } else if (II == Ident__has_feature) { diff --git a/clang/lib/Sema/SemaFunctionEffects.cpp b/clang/lib/Sema/SemaFunctionEffects.cpp index 8590ee8..4b63eb7 100644 --- a/clang/lib/Sema/SemaFunctionEffects.cpp +++ b/clang/lib/Sema/SemaFunctionEffects.cpp @@ -1208,8 +1208,16 @@ private: return true; } - // No Decl, just an Expr. Just check based on its type. - checkIndirectCall(Call, CalleeExpr->getType()); + // No Decl, just an Expr. Just check based on its type. Bound member + // functions are a special expression type and need to be specially + // unpacked. + QualType CalleeExprQT = CalleeExpr->getType(); + if (CalleeExpr->isBoundMemberFunction(Outer.S.getASTContext())) { + QualType QT = Expr::findBoundMemberType(CalleeExpr); + if (!QT.isNull()) + CalleeExprQT = QT; + } + checkIndirectCall(Call, CalleeExprQT); return true; } @@ -1271,7 +1279,15 @@ private: const CXXConstructorDecl *Ctor = Construct->getConstructor(); CallableInfo CI(*Ctor); followCall(CI, Construct->getLocation()); + return true; + } + bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *BTE) override { + const CXXDestructorDecl *Dtor = BTE->getTemporary()->getDestructor(); + if (Dtor != nullptr) { + CallableInfo CI(*Dtor); + followCall(CI, BTE->getBeginLoc()); + } return true; } diff --git a/clang/lib/Sema/SemaStmt.cpp b/clang/lib/Sema/SemaStmt.cpp index f398963..5b3ef1a 100644 --- a/clang/lib/Sema/SemaStmt.cpp +++ b/clang/lib/Sema/SemaStmt.cpp @@ -3281,6 +3281,9 @@ static Scope *FindLabeledBreakContinueScope(Sema &S, Scope *CurScope, SourceLocation LabelLoc, bool IsContinue) { assert(Target && "not a named break/continue?"); + + Target->markUsed(S.Context); + Scope *Found = nullptr; for (Scope *Scope = CurScope; Scope; Scope = Scope->getParent()) { if (Scope->isFunctionScope()) diff --git a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp index ad50600..bfcd397 100644 --- a/clang/lib/Sema/SemaTemplateDeductionGuide.cpp +++ b/clang/lib/Sema/SemaTemplateDeductionGuide.cpp @@ -659,7 +659,8 @@ private: SemaRef, MaterializedTypedefs, NestedPattern, TransformingOuterPatterns ? &Args : nullptr) .transform(NewDI); - + if (!NewDI) + return nullptr; // Resolving a wording defect, we also inherit default arguments from the // constructor. ExprResult NewDefArg; diff --git a/clang/lib/Sema/SemaType.cpp b/clang/lib/Sema/SemaType.cpp index 280b3c9..c483930 100644 --- a/clang/lib/Sema/SemaType.cpp +++ b/clang/lib/Sema/SemaType.cpp @@ -2358,6 +2358,11 @@ QualType Sema::BuildVectorType(QualType CurType, Expr *SizeExpr, return QualType(); } + if (VecSize->isNegative()) { + Diag(SizeExpr->getExprLoc(), diag::err_attribute_vec_negative_size); + return QualType(); + } + if (CurType->isDependentType()) return Context.getDependentVectorType(CurType, SizeExpr, AttrLoc, VectorKind::Generic); @@ -2394,7 +2399,7 @@ QualType Sema::BuildVectorType(QualType CurType, Expr *SizeExpr, VectorKind::Generic); } -QualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize, +QualType Sema::BuildExtVectorType(QualType T, Expr *SizeExpr, SourceLocation AttrLoc) { // Unlike gcc's vector_size attribute, we do not allow vectors to be defined // in conjunction with complex types (pointers, arrays, functions, etc.). @@ -2417,35 +2422,40 @@ QualType Sema::BuildExtVectorType(QualType T, Expr *ArraySize, BIT && CheckBitIntElementType(*this, AttrLoc, BIT)) return QualType(); - if (!ArraySize->isTypeDependent() && !ArraySize->isValueDependent()) { - std::optional<llvm::APSInt> vecSize = - ArraySize->getIntegerConstantExpr(Context); - if (!vecSize) { + if (!SizeExpr->isTypeDependent() && !SizeExpr->isValueDependent()) { + std::optional<llvm::APSInt> VecSize = + SizeExpr->getIntegerConstantExpr(Context); + if (!VecSize) { Diag(AttrLoc, diag::err_attribute_argument_type) - << "ext_vector_type" << AANT_ArgumentIntegerConstant - << ArraySize->getSourceRange(); + << "ext_vector_type" << AANT_ArgumentIntegerConstant + << SizeExpr->getSourceRange(); + return QualType(); + } + + if (VecSize->isNegative()) { + Diag(SizeExpr->getExprLoc(), diag::err_attribute_vec_negative_size); return QualType(); } - if (!vecSize->isIntN(32)) { + if (!VecSize->isIntN(32)) { Diag(AttrLoc, diag::err_attribute_size_too_large) - << ArraySize->getSourceRange() << "vector"; + << SizeExpr->getSourceRange() << "vector"; return QualType(); } // Unlike gcc's vector_size attribute, the size is specified as the // number of elements, not the number of bytes. - unsigned vectorSize = static_cast<unsigned>(vecSize->getZExtValue()); + unsigned VectorSize = static_cast<unsigned>(VecSize->getZExtValue()); - if (vectorSize == 0) { + if (VectorSize == 0) { Diag(AttrLoc, diag::err_attribute_zero_size) - << ArraySize->getSourceRange() << "vector"; + << SizeExpr->getSourceRange() << "vector"; return QualType(); } - return Context.getExtVectorType(T, vectorSize); + return Context.getExtVectorType(T, VectorSize); } - return Context.getDependentSizedExtVectorType(T, ArraySize, AttrLoc); + return Context.getDependentSizedExtVectorType(T, SizeExpr, AttrLoc); } QualType Sema::BuildMatrixType(QualType ElementTy, Expr *NumRows, Expr *NumCols, diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index e3106f8d..d552821 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -225,7 +225,7 @@ bool ChainedASTReaderListener::ReadPreprocessorOptions( } void ChainedASTReaderListener::ReadCounter(const serialization::ModuleFile &M, - unsigned Value) { + uint32_t Value) { First->ReadCounter(M, Value); Second->ReadCounter(M, Value); } @@ -973,7 +973,7 @@ bool PCHValidator::ReadHeaderSearchOptions(const HeaderSearchOptions &HSOpts, PP.getPreprocessorOpts()); } -void PCHValidator::ReadCounter(const ModuleFile &M, unsigned Value) { +void PCHValidator::ReadCounter(const ModuleFile &M, uint32_t Value) { PP.setCounterValue(Value); } diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 3ac338e..b1fd151 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -4374,8 +4374,7 @@ private: // parent of parent. We DON'T remove the enum constant from its parent. So // we don't need to care about merging problems here. if (auto *ECD = dyn_cast<EnumConstantDecl>(D); - ECD && DC.isFileContext() && ECD->getOwningModule() && - ECD->getTopLevelOwningNamedModule()->isNamedModule()) { + ECD && DC.isFileContext() && ECD->getTopLevelOwningNamedModule()) { if (llvm::all_of( DC.noload_lookup( cast<EnumDecl>(ECD->getDeclContext())->getDeclName()), diff --git a/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp index 70baab5..ec7ef23 100644 --- a/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp @@ -6,41 +6,45 @@ // //===----------------------------------------------------------------------===// // -// This file defines a variety of memory management related checkers, such as +// This file defines checkers that report memory management errors such as // leak, double free, and use-after-free. // -// The following checkers are defined here: +// The logic for modeling memory allocations is implemented in the checker +// family which is called 'MallocChecker' for historical reasons. (This name is +// inaccurate, something like 'DynamicMemory' would be more precise.) // -// * MallocChecker -// Despite its name, it models all sorts of memory allocations and -// de- or reallocation, including but not limited to malloc, free, -// relloc, new, delete. It also reports on a variety of memory misuse -// errors. -// Many other checkers interact very closely with this checker, in fact, -// most are merely options to this one. Other checkers may register -// MallocChecker, but do not enable MallocChecker's reports (more details -// to follow around its field, ChecksEnabled). -// It also has a boolean "Optimistic" checker option, which if set to true -// will cause the checker to model user defined memory management related -// functions annotated via the attribute ownership_takes, ownership_holds -// and ownership_returns. +// The reports produced by this backend are exposed through several frontends: +// * MallocChecker: reports all misuse of dynamic memory allocated by +// malloc, related functions (like calloc, realloc etc.) and the functions +// annotated by ownership_returns. (Here the name "MallocChecker" is +// reasonably accurate; don't confuse this checker frontend with the whole +// misnamed family.) +// * NewDeleteChecker: reports most misuse (anything but memory leaks) of +// memory managed by the C++ operators new and new[]. +// * NewDeleteLeaksChecker: reports leaks of dynamic memory allocated by +// the C++ operators new and new[]. +// * MismatchedDeallocatorChecker: reports situations where the allocation +// and deallocation is mismatched, e.g. memory allocated via malloc is +// passed to operator delete. +// * InnerPointerChecker: reports use of pointers to the internal buffer of +// a std::string instance after operations that invalidate them. +// * TaintedAllocChecker: reports situations where the size argument of a +// memory allocation function or array new operator is tainted (i.e. comes +// from an untrusted source and can be controlled by an attacker). // -// * NewDeleteChecker -// Enables the modeling of new, new[], delete, delete[] in MallocChecker, -// and checks for related double-free and use-after-free errors. +// In addition to these frontends this file also defines the registration +// functions for "unix.DynamicMemoryModeling". This registers the callbacks of +// the checker family MallocChecker without enabling any of the frontends and +// and handle two checker options which are attached to this "modeling +// checker" because they affect multiple checker frontends. // -// * NewDeleteLeaksChecker -// Checks for leaks related to new, new[], delete, delete[]. -// Depends on NewDeleteChecker. -// -// * MismatchedDeallocatorChecker -// Enables checking whether memory is deallocated with the corresponding -// allocation function in MallocChecker, such as malloc() allocated -// regions are only freed by free(), new by delete, new[] by delete[]. -// -// InnerPointerChecker interacts very closely with MallocChecker, but unlike -// the above checkers, it has it's own file, hence the many InnerPointerChecker -// related headers and non-static functions. +// Note that what the users see as the checker "cplusplus.InnerPointer" is a +// combination of the frontend InnerPointerChecker (within this family) which +// emits the bug reports and a separate checker class (also named +// InnerPointerChecker) which is defined in InnerPointerChecker.cpp and does a +// significant part of the modeling. This cooperation is enabled by several +// non-static helper functions that are defined within this translation unit +// and used in InnerPointerChecker.cpp. // //===----------------------------------------------------------------------===// diff --git a/clang/lib/StaticAnalyzer/Core/CallEvent.cpp b/clang/lib/StaticAnalyzer/Core/CallEvent.cpp index 62460cc..d04c827 100644 --- a/clang/lib/StaticAnalyzer/Core/CallEvent.cpp +++ b/clang/lib/StaticAnalyzer/Core/CallEvent.cpp @@ -230,13 +230,11 @@ static void findPtrToConstParams(llvm::SmallSet<unsigned, 4> &PreserveArgs, } ProgramStateRef CallEvent::invalidateRegions(unsigned BlockCount, - ProgramStateRef Orig) const { - ProgramStateRef Result = (Orig ? Orig : getState()); - + ProgramStateRef State) const { // Don't invalidate anything if the callee is marked pure/const. - if (const Decl *callee = getDecl()) - if (callee->hasAttr<PureAttr>() || callee->hasAttr<ConstAttr>()) - return Result; + if (const Decl *Callee = getDecl()) + if (Callee->hasAttr<PureAttr>() || Callee->hasAttr<ConstAttr>()) + return State; SmallVector<SVal, 8> ValuesToInvalidate; RegionAndSymbolInvalidationTraits ETraits; @@ -278,10 +276,10 @@ ProgramStateRef CallEvent::invalidateRegions(unsigned BlockCount, // Invalidate designated regions using the batch invalidation API. // NOTE: Even if RegionsToInvalidate is empty, we may still invalidate // global variables. - return Result->invalidateRegions(ValuesToInvalidate, getCFGElementRef(), - BlockCount, getLocationContext(), - /*CausedByPointerEscape*/ true, - /*Symbols=*/nullptr, this, &ETraits); + return State->invalidateRegions(ValuesToInvalidate, getCFGElementRef(), + BlockCount, getLocationContext(), + /*CausedByPointerEscape*/ true, + /*Symbols=*/nullptr, this, &ETraits); } ProgramPoint CallEvent::getProgramPoint(bool IsPreVisit, diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp index 75d7e26..00e3ef8 100644 --- a/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp +++ b/clang/lib/StaticAnalyzer/Core/ExprEngineCXX.cpp @@ -1013,7 +1013,7 @@ void ExprEngine::VisitCXXNewExpr(const CXXNewExpr *CNE, ExplodedNode *Pred, // FIXME: Once we figure out how we want allocators to work, // we should be using the usual pre-/(default-)eval-/post-call checkers // here. - State = Call->invalidateRegions(blockCount); + State = Call->invalidateRegions(blockCount, State); if (!State) return; diff --git a/clang/test/AST/ByteCode/cxx11.cpp b/clang/test/AST/ByteCode/cxx11.cpp index 427d3a1..e283a7b 100644 --- a/clang/test/AST/ByteCode/cxx11.cpp +++ b/clang/test/AST/ByteCode/cxx11.cpp @@ -374,7 +374,7 @@ namespace GH150709 { namespace DiscardedAddrLabel { void foo(void) { L: - *&&L; // both-error {{indirection not permitted}} \ + *&&L; // both-error {{indirection not permitted on operand of type 'void *'}} \ // both-warning {{expression result unused}} } } diff --git a/clang/test/C/C2y/n3457.c b/clang/test/C/C2y/n3457.c new file mode 100644 index 0000000..d71a3f3 --- /dev/null +++ b/clang/test/C/C2y/n3457.c @@ -0,0 +1,38 @@ +// RUN: %clang_cc1 -verify=ext -std=c23 -pedantic %s +// RUN: %clang_cc1 -verify=ext -pedantic -x c++ %s +// RUN: %clang_cc1 -verify=pre -std=c2y -pedantic -Wpre-c2y-compat %s + +/* WG14 N3457: Clang 22 + * The __COUNTER__ predefined macro + * + * This predefined macro was supported as an extension in earlier versions of + * Clang, but the required diagnostics for the limits were not added until 22. + */ + +// Ensure that __COUNTER__ starts from 0. +static_assert(__COUNTER__ == 0); /* ext-warning {{'__COUNTER__' is a C2y extension}} + pre-warning {{'__COUNTER__' is incompatible with standards before C2y}} + */ + +// Ensure that the produced value can be used with token concatenation. +#define CAT_IMPL(a, b) a ## b +#define CAT(a, b) CAT_IMPL(a, b) +#define NAME_WITH_COUNTER(a) CAT(a, __COUNTER__) +void test() { + // Because this is the 2nd expansion, this defines test1. + int NAME_WITH_COUNTER(test); /* ext-warning {{'__COUNTER__' is a C2y extension}} + pre-warning {{'__COUNTER__' is incompatible with standards before C2y}} + */ + int other_test = test1; // Ok +} + +// Ensure that __COUNTER__ increments each time you mention it. +static_assert(__COUNTER__ == 2); /* ext-warning {{'__COUNTER__' is a C2y extension}} + pre-warning {{'__COUNTER__' is incompatible with standards before C2y}} + */ +static_assert(__COUNTER__ == 3); /* ext-warning {{'__COUNTER__' is a C2y extension}} + pre-warning {{'__COUNTER__' is incompatible with standards before C2y}} + */ +static_assert(__COUNTER__ == 4); /* ext-warning {{'__COUNTER__' is a C2y extension}} + pre-warning {{'__COUNTER__' is incompatible with standards before C2y}} + */ diff --git a/clang/test/C/C2y/n3457_1.c b/clang/test/C/C2y/n3457_1.c new file mode 100644 index 0000000..76c5a0b --- /dev/null +++ b/clang/test/C/C2y/n3457_1.c @@ -0,0 +1,20 @@ +// RUN: %clang_cc1 -verify -std=c2y -finitial-counter-value=2147483646 %s + +// The value produced needs to be a type that's representable with a signed +// long. However, the actual type it expands to does *not* need to be forced to +// be signed long because that would generally mean suffixing the value with L, +// which would be very surprising for folks using this to generate unique ids. +// We'll test this by ensuring the largest value can be expanded properly and +// an assertion that signed long is always at least four bytes wide (which is +// what's required to represent that maximal value). +// +// So we set the initial counter value to 2147483646, we'll validate that, +// increment it once to get to the maximal value and ensure there's no +// diagnostic, then increment again to ensure we get the constraint violation. + +static_assert(__COUNTER__ == 2147483646); // Test and increment +static_assert(__COUNTER__ == 2147483647); // Test and increment + +// This one should fail. +signed long i = __COUNTER__; // expected-error {{'__COUNTER__' value cannot exceed 2'147'483'647}} + diff --git a/clang/test/C/C2y/n3457_2.c b/clang/test/C/C2y/n3457_2.c new file mode 100644 index 0000000..018c8f4 --- /dev/null +++ b/clang/test/C/C2y/n3457_2.c @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -verify=good -std=c2y -finitial-counter-value=2147483648 %s +// RUN: %clang_cc1 -verify -std=c2y -finitial-counter-value=2147483648 -DEXPAND_IT %s +// good-no-diagnostics + +// This sets the intial __COUNTER__ value to something that's too big. Setting +// the value too large is fine. Expanding to a too-large value is not. +#ifdef EXPAND_IT + // This one should fail. + signed long i = __COUNTER__; // expected-error {{'__COUNTER__' value cannot exceed 2'147'483'647}} +#endif diff --git a/clang/test/CIR/CodeGen/builtins-floating-point.c b/clang/test/CIR/CodeGen/builtins-floating-point.c index 193cc172..8bdc43c 100644 --- a/clang/test/CIR/CodeGen/builtins-floating-point.c +++ b/clang/test/CIR/CodeGen/builtins-floating-point.c @@ -7,14 +7,21 @@ float cosf(float f) { return __builtin_cosf(f); - // CHECK: %{{.*}} = cir.cos {{.*}} : !cir.float + // CIR: %{{.*}} = cir.cos %{{.*}} : !cir.float // LLVM: %{{.*}} = call float @llvm.cos.f32(float %{{.*}}) // OGCG: %{{.*}} = call float @llvm.cos.f32(float %{{.*}}) } double cos(double f) { return __builtin_cos(f); - // CIR: {{.+}} = cir.cos {{.+}} : !cir.double + // CIR: %{{.*}} = cir.cos %{{.*}} : !cir.double // LLVM: %{{.*}} = call double @llvm.cos.f64(double %{{.*}}) // OGCG: %{{.*}} = call double @llvm.cos.f64(double %{{.*}}) } + +float ceil(float f) { + return __builtin_ceilf(f); + // CIR: %{{.*}} = cir.ceil %{{.*}} : !cir.float + // LLVM: %{{.*}} = call float @llvm.ceil.f32(float %{{.*}}) + // OGCG: %{{.*}} = call float @llvm.ceil.f32(float %{{.*}}) +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexp_v_16.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexp_v_16.c new file mode 100644 index 0000000..a0d5845 --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexp_v_16.c @@ -0,0 +1,131 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zvfh \ +// RUN: -target-feature +xsfvfexp16e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexp_v_f16mf4( +// CHECK-RV64-SAME: <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexp.nxv1f16.i64(<vscale x 1 x half> poison, <vscale x 1 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexp_v_f16mf4(vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16mf4(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2( +// CHECK-RV64-SAME: <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.nxv2f16.i64(<vscale x 2 x half> poison, <vscale x 2 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2(vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16mf2(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1( +// CHECK-RV64-SAME: <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.nxv4f16.i64(<vscale x 4 x half> poison, <vscale x 4 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1(vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m1(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2( +// CHECK-RV64-SAME: <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.nxv8f16.i64(<vscale x 8 x half> poison, <vscale x 8 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2(vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m2(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4( +// CHECK-RV64-SAME: <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.nxv16f16.i64(<vscale x 16 x half> poison, <vscale x 16 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4(vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m4(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8( +// CHECK-RV64-SAME: <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.nxv32f16.i64(<vscale x 32 x half> poison, <vscale x 32 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8(vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m8(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexp_v_f16mf4_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexp.mask.nxv1f16.i64(<vscale x 1 x half> poison, <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexp_v_f16mf4_m(vbool64_t vm, vfloat16mf4_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_f16mf4_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.mask.nxv2f16.i64(<vscale x 2 x half> poison, <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2_m(vbool32_t vm, vfloat16mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_f16mf2_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.mask.nxv4f16.i64(<vscale x 4 x half> poison, <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1_m(vbool16_t vm, vfloat16m1_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_f16m1_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.mask.nxv8f16.i64(<vscale x 8 x half> poison, <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2_m(vbool8_t vm, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m2_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4_m( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.mask.nxv16f16.i64(<vscale x 16 x half> poison, <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4_m(vbool4_t vm, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m4_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8_m( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.mask.nxv32f16.i64(<vscale x 32 x half> poison, <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8_m(vbool2_t vm, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m8_m(vm, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexp_v_32.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexp_v_32.c new file mode 100644 index 0000000..25d0991 --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexp_v_32.c @@ -0,0 +1,111 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zve32f \ +// RUN: -target-feature +xsfvfexp32e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2( +// CHECK-RV64-SAME: <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.nxv1f32.i64(<vscale x 1 x float> poison, <vscale x 1 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2(vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32mf2(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1( +// CHECK-RV64-SAME: <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.nxv2f32.i64(<vscale x 2 x float> poison, <vscale x 2 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1(vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m1(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2( +// CHECK-RV64-SAME: <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.nxv4f32.i64(<vscale x 4 x float> poison, <vscale x 4 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2(vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m2(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4( +// CHECK-RV64-SAME: <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.nxv8f32.i64(<vscale x 8 x float> poison, <vscale x 8 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4(vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m4(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8( +// CHECK-RV64-SAME: <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.nxv16f32.i64(<vscale x 16 x float> poison, <vscale x 16 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8(vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m8(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.mask.nxv1f32.i64(<vscale x 1 x float> poison, <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2_m(vbool64_t vm, vfloat32mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_f32mf2_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.mask.nxv2f32.i64(<vscale x 2 x float> poison, <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1_m(vbool32_t vm, vfloat32m1_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_f32m1_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.mask.nxv4f32.i64(<vscale x 4 x float> poison, <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2_m(vbool16_t vm, vfloat32m2_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_f32m2_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.mask.nxv8f32.i64(<vscale x 8 x float> poison, <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4_m(vbool8_t vm, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m4_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8_m( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.mask.nxv16f32.i64(<vscale x 16 x float> poison, <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8_m(vbool4_t vm, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m8_m(vm, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexp_v_bf.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexp_v_bf.c new file mode 100644 index 0000000..9fc332a --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexp_v_bf.c @@ -0,0 +1,135 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zve32f \ +// RUN: -target-feature +zvfbfmin -target-feature +xsfvfbfexp16e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4( +// CHECK-RV64-SAME: <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.nxv1bf16.i64(<vscale x 1 x bfloat> poison, <vscale x 1 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4(vbfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16mf4(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2( +// CHECK-RV64-SAME: <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.nxv2bf16.i64(<vscale x 2 x bfloat> poison, <vscale x 2 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2(vbfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16mf2(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1( +// CHECK-RV64-SAME: <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.nxv4bf16.i64(<vscale x 4 x bfloat> poison, <vscale x 4 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1(vbfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m1(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2( +// CHECK-RV64-SAME: <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.nxv8bf16.i64(<vscale x 8 x bfloat> poison, <vscale x 8 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2(vbfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m2(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4( +// CHECK-RV64-SAME: <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.nxv16bf16.i64(<vscale x 16 x bfloat> poison, <vscale x 16 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4(vbfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m4(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8( +// CHECK-RV64-SAME: <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.nxv32bf16.i64(<vscale x 32 x bfloat> poison, <vscale x 32 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8(vbfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m8(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv1bf16.i64(<vscale x 1 x bfloat> poison, <vscale x 1 x bfloat> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4_m(vbool64_t vm, vbfloat16mf4_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_bf16mf4_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv2bf16.i64(<vscale x 2 x bfloat> poison, <vscale x 2 x bfloat> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2_m(vbool32_t vm, vbfloat16mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_bf16mf2_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv4bf16.i64(<vscale x 4 x bfloat> poison, <vscale x 4 x bfloat> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1_m(vbool16_t vm, vbfloat16m1_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_bf16m1_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv8bf16.i64(<vscale x 8 x bfloat> poison, <vscale x 8 x bfloat> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2_m(vbool8_t vm, vbfloat16m2_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_bf16m2_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4_m( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv16bf16.i64(<vscale x 16 x bfloat> poison, <vscale x 16 x bfloat> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4_m(vbool4_t vm, vbfloat16m4_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_bf16m4_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8_m( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv32bf16.i64(<vscale x 32 x bfloat> poison, <vscale x 32 x bfloat> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8_m(vbool2_t vm, vbfloat16m8_t vs2, + size_t vl) { + return __riscv_sf_vfexp_v_bf16m8_m(vm, vs2, vl); +} + diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexpa_v.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexpa_v.c new file mode 100644 index 0000000..67a9220 --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexpa_v.c @@ -0,0 +1,234 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 4 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64f -target-feature +zvfh \ +// RUN: -target-feature +xsfvfexpa -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4( +// CHECK-RV64-SAME: <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.nxv1f16.i64(<vscale x 1 x half> poison, <vscale x 1 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4(vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16mf4(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2( +// CHECK-RV64-SAME: <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.nxv2f16.i64(<vscale x 2 x half> poison, <vscale x 2 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2(vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16mf2(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1( +// CHECK-RV64-SAME: <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.nxv4f16.i64(<vscale x 4 x half> poison, <vscale x 4 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1(vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m1(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2( +// CHECK-RV64-SAME: <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.nxv8f16.i64(<vscale x 8 x half> poison, <vscale x 8 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2(vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m2(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4( +// CHECK-RV64-SAME: <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.nxv16f16.i64(<vscale x 16 x half> poison, <vscale x 16 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4(vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m4(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8( +// CHECK-RV64-SAME: <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.nxv32f16.i64(<vscale x 32 x half> poison, <vscale x 32 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8(vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m8(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2( +// CHECK-RV64-SAME: <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.nxv1f32.i64(<vscale x 1 x float> poison, <vscale x 1 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2(vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32mf2(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1( +// CHECK-RV64-SAME: <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.nxv2f32.i64(<vscale x 2 x float> poison, <vscale x 2 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1(vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m1(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2( +// CHECK-RV64-SAME: <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.nxv4f32.i64(<vscale x 4 x float> poison, <vscale x 4 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2(vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m2(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4( +// CHECK-RV64-SAME: <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.nxv8f32.i64(<vscale x 8 x float> poison, <vscale x 8 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4(vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m4(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8( +// CHECK-RV64-SAME: <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.nxv16f32.i64(<vscale x 16 x float> poison, <vscale x 16 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8(vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m8(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.mask.nxv1f16.i64(<vscale x 1 x half> poison, <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4_m(vbool64_t vm, vfloat16mf4_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_v_f16mf4_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.mask.nxv2f16.i64(<vscale x 2 x half> poison, <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2_m(vbool32_t vm, vfloat16mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_v_f16mf2_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.mask.nxv4f16.i64(<vscale x 4 x half> poison, <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1_m(vbool16_t vm, vfloat16m1_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_v_f16m1_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.mask.nxv8f16.i64(<vscale x 8 x half> poison, <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2_m(vbool8_t vm, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m2_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4_m( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.mask.nxv16f16.i64(<vscale x 16 x half> poison, <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4_m(vbool4_t vm, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m4_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8_m( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.mask.nxv32f16.i64(<vscale x 32 x half> poison, <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8_m(vbool2_t vm, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m8_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.mask.nxv1f32.i64(<vscale x 1 x float> poison, <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2_m(vbool64_t vm, vfloat32mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_v_f32mf2_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.mask.nxv2f32.i64(<vscale x 2 x float> poison, <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1_m(vbool32_t vm, vfloat32m1_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_v_f32m1_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.mask.nxv4f32.i64(<vscale x 4 x float> poison, <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2_m(vbool16_t vm, vfloat32m2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_v_f32m2_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.mask.nxv8f32.i64(<vscale x 8 x float> poison, <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4_m(vbool8_t vm, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m4_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8_m( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.mask.nxv16f32.i64(<vscale x 16 x float> poison, <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8_m(vbool4_t vm, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m8_m(vm, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexpa_v_64.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexpa_v_64.c new file mode 100644 index 0000000..fd6f82d --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/non-overloaded/sf_vfexpa_v_64.c @@ -0,0 +1,90 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 4 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +xsfvfexpa64e \ +// RUN: -disable-O0-optnone -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1( +// CHECK-RV64-SAME: <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.nxv1f64.i64(<vscale x 1 x double> poison, <vscale x 1 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1(vfloat64m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m1(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2( +// CHECK-RV64-SAME: <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.nxv2f64.i64(<vscale x 2 x double> poison, <vscale x 2 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2(vfloat64m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m2(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4( +// CHECK-RV64-SAME: <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.nxv4f64.i64(<vscale x 4 x double> poison, <vscale x 4 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4(vfloat64m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m4(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8( +// CHECK-RV64-SAME: <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.nxv8f64.i64(<vscale x 8 x double> poison, <vscale x 8 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8(vfloat64m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m8(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.mask.nxv1f64.i64(<vscale x 1 x double> poison, <vscale x 1 x double> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1_m(vbool64_t vm, vfloat64m1_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_v_f64m1_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.mask.nxv2f64.i64(<vscale x 2 x double> poison, <vscale x 2 x double> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2_m(vbool32_t vm, vfloat64m2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_v_f64m2_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.mask.nxv4f64.i64(<vscale x 4 x double> poison, <vscale x 4 x double> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4_m(vbool16_t vm, vfloat64m4_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_v_f64m4_m(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.mask.nxv8f64.i64(<vscale x 8 x double> poison, <vscale x 8 x double> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8_m(vbool8_t vm, vfloat64m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m8_m(vm, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexp_v_16.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexp_v_16.c new file mode 100644 index 0000000..0e769ed --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexp_v_16.c @@ -0,0 +1,131 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zvfh \ +// RUN: -target-feature +xsfvfexp16e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexp_v_f16mf4( +// CHECK-RV64-SAME: <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexp.nxv1f16.i64(<vscale x 1 x half> poison, <vscale x 1 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexp_v_f16mf4(vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2( +// CHECK-RV64-SAME: <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.nxv2f16.i64(<vscale x 2 x half> poison, <vscale x 2 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2(vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1( +// CHECK-RV64-SAME: <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.nxv4f16.i64(<vscale x 4 x half> poison, <vscale x 4 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1(vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2( +// CHECK-RV64-SAME: <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.nxv8f16.i64(<vscale x 8 x half> poison, <vscale x 8 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2(vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4( +// CHECK-RV64-SAME: <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.nxv16f16.i64(<vscale x 16 x half> poison, <vscale x 16 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4(vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8( +// CHECK-RV64-SAME: <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.nxv32f16.i64(<vscale x 32 x half> poison, <vscale x 32 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8(vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexp_v_f16mf4_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexp.mask.nxv1f16.i64(<vscale x 1 x half> poison, <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexp_v_f16mf4_m(vbool64_t vm, vfloat16mf4_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.mask.nxv2f16.i64(<vscale x 2 x half> poison, <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2_m(vbool32_t vm, vfloat16mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.mask.nxv4f16.i64(<vscale x 4 x half> poison, <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1_m(vbool16_t vm, vfloat16m1_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.mask.nxv8f16.i64(<vscale x 8 x half> poison, <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2_m(vbool8_t vm, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4_m( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.mask.nxv16f16.i64(<vscale x 16 x half> poison, <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4_m(vbool4_t vm, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8_m( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.mask.nxv32f16.i64(<vscale x 32 x half> poison, <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8_m(vbool2_t vm, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexp_v_32.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexp_v_32.c new file mode 100644 index 0000000..3df1eaa --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexp_v_32.c @@ -0,0 +1,111 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zve32f \ +// RUN: -target-feature +xsfvfexp32e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2( +// CHECK-RV64-SAME: <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.nxv1f32.i64(<vscale x 1 x float> poison, <vscale x 1 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2(vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1( +// CHECK-RV64-SAME: <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.nxv2f32.i64(<vscale x 2 x float> poison, <vscale x 2 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1(vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2( +// CHECK-RV64-SAME: <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.nxv4f32.i64(<vscale x 4 x float> poison, <vscale x 4 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2(vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4( +// CHECK-RV64-SAME: <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.nxv8f32.i64(<vscale x 8 x float> poison, <vscale x 8 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4(vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8( +// CHECK-RV64-SAME: <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.nxv16f32.i64(<vscale x 16 x float> poison, <vscale x 16 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8(vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.mask.nxv1f32.i64(<vscale x 1 x float> poison, <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2_m(vbool64_t vm, vfloat32mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.mask.nxv2f32.i64(<vscale x 2 x float> poison, <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1_m(vbool32_t vm, vfloat32m1_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.mask.nxv4f32.i64(<vscale x 4 x float> poison, <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2_m(vbool16_t vm, vfloat32m2_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.mask.nxv8f32.i64(<vscale x 8 x float> poison, <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4_m(vbool8_t vm, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8_m( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.mask.nxv16f32.i64(<vscale x 16 x float> poison, <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8_m(vbool4_t vm, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexp_v_bf.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexp_v_bf.c new file mode 100644 index 0000000..6179dbe --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexp_v_bf.c @@ -0,0 +1,134 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zve32f \ +// RUN: -target-feature +zvfbfmin -target-feature +xsfvfbfexp16e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4( +// CHECK-RV64-SAME: <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.nxv1bf16.i64(<vscale x 1 x bfloat> poison, <vscale x 1 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4(vbfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2( +// CHECK-RV64-SAME: <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.nxv2bf16.i64(<vscale x 2 x bfloat> poison, <vscale x 2 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2(vbfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1( +// CHECK-RV64-SAME: <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.nxv4bf16.i64(<vscale x 4 x bfloat> poison, <vscale x 4 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1(vbfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2( +// CHECK-RV64-SAME: <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.nxv8bf16.i64(<vscale x 8 x bfloat> poison, <vscale x 8 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2(vbfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4( +// CHECK-RV64-SAME: <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.nxv16bf16.i64(<vscale x 16 x bfloat> poison, <vscale x 16 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4(vbfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8( +// CHECK-RV64-SAME: <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.nxv32bf16.i64(<vscale x 32 x bfloat> poison, <vscale x 32 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8(vbfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv1bf16.i64(<vscale x 1 x bfloat> poison, <vscale x 1 x bfloat> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4_m(vbool64_t vm, vbfloat16mf4_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv2bf16.i64(<vscale x 2 x bfloat> poison, <vscale x 2 x bfloat> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2_m(vbool32_t vm, vbfloat16mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv4bf16.i64(<vscale x 4 x bfloat> poison, <vscale x 4 x bfloat> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1_m(vbool16_t vm, vbfloat16m1_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv8bf16.i64(<vscale x 8 x bfloat> poison, <vscale x 8 x bfloat> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2_m(vbool8_t vm, vbfloat16m2_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4_m( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv16bf16.i64(<vscale x 16 x bfloat> poison, <vscale x 16 x bfloat> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4_m(vbool4_t vm, vbfloat16m4_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8_m( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv32bf16.i64(<vscale x 32 x bfloat> poison, <vscale x 32 x bfloat> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8_m(vbool2_t vm, vbfloat16m8_t vs2, + size_t vl) { + return __riscv_sf_vfexp(vm, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexpa_v.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexpa_v.c new file mode 100644 index 0000000..1ddbb0b --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexpa_v.c @@ -0,0 +1,234 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 4 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64f -target-feature +zvfh \ +// RUN: -target-feature +xsfvfexpa -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4( +// CHECK-RV64-SAME: <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.nxv1f16.i64(<vscale x 1 x half> poison, <vscale x 1 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4(vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2( +// CHECK-RV64-SAME: <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.nxv2f16.i64(<vscale x 2 x half> poison, <vscale x 2 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2(vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1( +// CHECK-RV64-SAME: <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.nxv4f16.i64(<vscale x 4 x half> poison, <vscale x 4 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1(vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2( +// CHECK-RV64-SAME: <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.nxv8f16.i64(<vscale x 8 x half> poison, <vscale x 8 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2(vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4( +// CHECK-RV64-SAME: <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.nxv16f16.i64(<vscale x 16 x half> poison, <vscale x 16 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4(vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8( +// CHECK-RV64-SAME: <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.nxv32f16.i64(<vscale x 32 x half> poison, <vscale x 32 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8(vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2( +// CHECK-RV64-SAME: <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.nxv1f32.i64(<vscale x 1 x float> poison, <vscale x 1 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2(vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1( +// CHECK-RV64-SAME: <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.nxv2f32.i64(<vscale x 2 x float> poison, <vscale x 2 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1(vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2( +// CHECK-RV64-SAME: <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.nxv4f32.i64(<vscale x 4 x float> poison, <vscale x 4 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2(vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4( +// CHECK-RV64-SAME: <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.nxv8f32.i64(<vscale x 8 x float> poison, <vscale x 8 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4(vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8( +// CHECK-RV64-SAME: <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.nxv16f32.i64(<vscale x 16 x float> poison, <vscale x 16 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8(vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.mask.nxv1f16.i64(<vscale x 1 x half> poison, <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4_m(vbool64_t vm, vfloat16mf4_t vs2, + size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.mask.nxv2f16.i64(<vscale x 2 x half> poison, <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2_m(vbool32_t vm, vfloat16mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.mask.nxv4f16.i64(<vscale x 4 x half> poison, <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1_m(vbool16_t vm, vfloat16m1_t vs2, + size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.mask.nxv8f16.i64(<vscale x 8 x half> poison, <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2_m(vbool8_t vm, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4_m( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.mask.nxv16f16.i64(<vscale x 16 x half> poison, <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4_m(vbool4_t vm, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8_m( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.mask.nxv32f16.i64(<vscale x 32 x half> poison, <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8_m(vbool2_t vm, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.mask.nxv1f32.i64(<vscale x 1 x float> poison, <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2_m(vbool64_t vm, vfloat32mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.mask.nxv2f32.i64(<vscale x 2 x float> poison, <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1_m(vbool32_t vm, vfloat32m1_t vs2, + size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.mask.nxv4f32.i64(<vscale x 4 x float> poison, <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2_m(vbool16_t vm, vfloat32m2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.mask.nxv8f32.i64(<vscale x 8 x float> poison, <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4_m(vbool8_t vm, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8_m( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.mask.nxv16f32.i64(<vscale x 16 x float> poison, <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8_m(vbool4_t vm, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexpa_v_64.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexpa_v_64.c new file mode 100644 index 0000000..165879a --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/non-policy/overloaded/sf_vfexpa_v_64.c @@ -0,0 +1,90 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 4 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +xsfvfexpa64e \ +// RUN: -disable-O0-optnone -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1( +// CHECK-RV64-SAME: <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.nxv1f64.i64(<vscale x 1 x double> poison, <vscale x 1 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1(vfloat64m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2( +// CHECK-RV64-SAME: <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.nxv2f64.i64(<vscale x 2 x double> poison, <vscale x 2 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2(vfloat64m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4( +// CHECK-RV64-SAME: <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.nxv4f64.i64(<vscale x 4 x double> poison, <vscale x 4 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4(vfloat64m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8( +// CHECK-RV64-SAME: <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.nxv8f64.i64(<vscale x 8 x double> poison, <vscale x 8 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8(vfloat64m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1_m( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.mask.nxv1f64.i64(<vscale x 1 x double> poison, <vscale x 1 x double> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1_m(vbool64_t vm, vfloat64m1_t vs2, + size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2_m( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.mask.nxv2f64.i64(<vscale x 2 x double> poison, <vscale x 2 x double> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2_m(vbool32_t vm, vfloat64m2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4_m( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.mask.nxv4f64.i64(<vscale x 4 x double> poison, <vscale x 4 x double> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4_m(vbool16_t vm, vfloat64m4_t vs2, + size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8_m( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.mask.nxv8f64.i64(<vscale x 8 x double> poison, <vscale x 8 x double> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 3) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8_m(vbool8_t vm, vfloat64m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa(vm, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexp_v_16.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexp_v_16.c new file mode 100644 index 0000000..aed6d87 --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexp_v_16.c @@ -0,0 +1,248 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zvfh \ +// RUN: -target-feature +xsfvfexp16e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexp_v_f16mf4_tu( +// CHECK-RV64-SAME: <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexp.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexp_v_f16mf4_tu(vfloat16mf4_t vd, vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16mf4_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2_tu( +// CHECK-RV64-SAME: <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2_tu(vfloat16mf2_t vd, vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16mf2_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1_tu( +// CHECK-RV64-SAME: <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1_tu(vfloat16m1_t vd, vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m1_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2_tu( +// CHECK-RV64-SAME: <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2_tu(vfloat16m2_t vd, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m2_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4_tu( +// CHECK-RV64-SAME: <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4_tu(vfloat16m4_t vd, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m4_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8_tu( +// CHECK-RV64-SAME: <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8_tu(vfloat16m8_t vd, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m8_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexp_v_f16mf4_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexp.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexp_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16mf4_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16mf2_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m1_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m2_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4_tum( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m4_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8_tum( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m8_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexp_v_f16mf4_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexp.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexp_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16mf4_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16mf2_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m1_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m2_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4_tumu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m4_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8_tumu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m8_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexp_v_f16mf4_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexp.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexp_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16mf4_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16mf2_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m1_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m2_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4_mu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m4_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8_mu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f16m8_mu(vm, vd, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexp_v_32.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexp_v_32.c new file mode 100644 index 0000000..374f324 --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexp_v_32.c @@ -0,0 +1,208 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zve32f \ +// RUN: -target-feature +xsfvfexp32e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2_tu( +// CHECK-RV64-SAME: <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2_tu(vfloat32mf2_t vd, vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32mf2_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1_tu( +// CHECK-RV64-SAME: <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1_tu(vfloat32m1_t vd, vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m1_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2_tu( +// CHECK-RV64-SAME: <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2_tu(vfloat32m2_t vd, vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m2_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4_tu( +// CHECK-RV64-SAME: <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4_tu(vfloat32m4_t vd, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m4_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8_tu( +// CHECK-RV64-SAME: <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8_tu(vfloat32m8_t vd, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m8_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2_tum(vbool64_t vm, vfloat32mf2_t vd, vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32mf2_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1_tum(vbool32_t vm, vfloat32m1_t vd, vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m1_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2_tum(vbool16_t vm, vfloat32m2_t vd, vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m2_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4_tum(vbool8_t vm, vfloat32m4_t vd, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m4_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8_tum( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8_tum(vbool4_t vm, vfloat32m8_t vd, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m8_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2_tumu(vbool64_t vm, vfloat32mf2_t vd, vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32mf2_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1_tumu(vbool32_t vm, vfloat32m1_t vd, vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m1_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2_tumu(vbool16_t vm, vfloat32m2_t vd, vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m2_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4_tumu(vbool8_t vm, vfloat32m4_t vd, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m4_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8_tumu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8_tumu(vbool4_t vm, vfloat32m8_t vd, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m8_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2_mu(vbool64_t vm, vfloat32mf2_t vd, vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32mf2_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1_mu(vbool32_t vm, vfloat32m1_t vd, vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m1_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2_mu(vbool16_t vm, vfloat32m2_t vd, vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m2_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4_mu(vbool8_t vm, vfloat32m4_t vd, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m4_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8_mu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8_mu(vbool4_t vm, vfloat32m8_t vd, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_f32m8_mu(vm, vd, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexp_v_bf.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexp_v_bf.c new file mode 100644 index 0000000..aec0b9f --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexp_v_bf.c @@ -0,0 +1,248 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zve32f \ +// RUN: -target-feature +zvfbfmin -target-feature +xsfvfbfexp16e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4_tu( +// CHECK-RV64-SAME: <vscale x 1 x bfloat> [[VD:%.*]], <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.nxv1bf16.i64(<vscale x 1 x bfloat> [[VD]], <vscale x 1 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4_tu(vbfloat16mf4_t vd, vbfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16mf4_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2_tu( +// CHECK-RV64-SAME: <vscale x 2 x bfloat> [[VD:%.*]], <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.nxv2bf16.i64(<vscale x 2 x bfloat> [[VD]], <vscale x 2 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2_tu(vbfloat16mf2_t vd, vbfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16mf2_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1_tu( +// CHECK-RV64-SAME: <vscale x 4 x bfloat> [[VD:%.*]], <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.nxv4bf16.i64(<vscale x 4 x bfloat> [[VD]], <vscale x 4 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1_tu(vbfloat16m1_t vd, vbfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m1_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2_tu( +// CHECK-RV64-SAME: <vscale x 8 x bfloat> [[VD:%.*]], <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.nxv8bf16.i64(<vscale x 8 x bfloat> [[VD]], <vscale x 8 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2_tu(vbfloat16m2_t vd, vbfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m2_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4_tu( +// CHECK-RV64-SAME: <vscale x 16 x bfloat> [[VD:%.*]], <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.nxv16bf16.i64(<vscale x 16 x bfloat> [[VD]], <vscale x 16 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4_tu(vbfloat16m4_t vd, vbfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m4_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8_tu( +// CHECK-RV64-SAME: <vscale x 32 x bfloat> [[VD:%.*]], <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.nxv32bf16.i64(<vscale x 32 x bfloat> [[VD]], <vscale x 32 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8_tu(vbfloat16m8_t vd, vbfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m8_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x bfloat> [[VD:%.*]], <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv1bf16.i64(<vscale x 1 x bfloat> [[VD]], <vscale x 1 x bfloat> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4_tum(vbool64_t vm, vbfloat16mf4_t vd, vbfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16mf4_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x bfloat> [[VD:%.*]], <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv2bf16.i64(<vscale x 2 x bfloat> [[VD]], <vscale x 2 x bfloat> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2_tum(vbool32_t vm, vbfloat16mf2_t vd, vbfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16mf2_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x bfloat> [[VD:%.*]], <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv4bf16.i64(<vscale x 4 x bfloat> [[VD]], <vscale x 4 x bfloat> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1_tum(vbool16_t vm, vbfloat16m1_t vd, vbfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m1_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x bfloat> [[VD:%.*]], <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv8bf16.i64(<vscale x 8 x bfloat> [[VD]], <vscale x 8 x bfloat> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2_tum(vbool8_t vm, vbfloat16m2_t vd, vbfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m2_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4_tum( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x bfloat> [[VD:%.*]], <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv16bf16.i64(<vscale x 16 x bfloat> [[VD]], <vscale x 16 x bfloat> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4_tum(vbool4_t vm, vbfloat16m4_t vd, vbfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m4_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8_tum( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x bfloat> [[VD:%.*]], <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv32bf16.i64(<vscale x 32 x bfloat> [[VD]], <vscale x 32 x bfloat> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8_tum(vbool2_t vm, vbfloat16m8_t vd, vbfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m8_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x bfloat> [[VD:%.*]], <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv1bf16.i64(<vscale x 1 x bfloat> [[VD]], <vscale x 1 x bfloat> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4_tumu(vbool64_t vm, vbfloat16mf4_t vd, vbfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16mf4_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x bfloat> [[VD:%.*]], <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv2bf16.i64(<vscale x 2 x bfloat> [[VD]], <vscale x 2 x bfloat> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2_tumu(vbool32_t vm, vbfloat16mf2_t vd, vbfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16mf2_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x bfloat> [[VD:%.*]], <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv4bf16.i64(<vscale x 4 x bfloat> [[VD]], <vscale x 4 x bfloat> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1_tumu(vbool16_t vm, vbfloat16m1_t vd, vbfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m1_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x bfloat> [[VD:%.*]], <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv8bf16.i64(<vscale x 8 x bfloat> [[VD]], <vscale x 8 x bfloat> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2_tumu(vbool8_t vm, vbfloat16m2_t vd, vbfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m2_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4_tumu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x bfloat> [[VD:%.*]], <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv16bf16.i64(<vscale x 16 x bfloat> [[VD]], <vscale x 16 x bfloat> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4_tumu(vbool4_t vm, vbfloat16m4_t vd, vbfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m4_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8_tumu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x bfloat> [[VD:%.*]], <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv32bf16.i64(<vscale x 32 x bfloat> [[VD]], <vscale x 32 x bfloat> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8_tumu(vbool2_t vm, vbfloat16m8_t vd, vbfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m8_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x bfloat> [[VD:%.*]], <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv1bf16.i64(<vscale x 1 x bfloat> [[VD]], <vscale x 1 x bfloat> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4_mu(vbool64_t vm, vbfloat16mf4_t vd, vbfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16mf4_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x bfloat> [[VD:%.*]], <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv2bf16.i64(<vscale x 2 x bfloat> [[VD]], <vscale x 2 x bfloat> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2_mu(vbool32_t vm, vbfloat16mf2_t vd, vbfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16mf2_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x bfloat> [[VD:%.*]], <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv4bf16.i64(<vscale x 4 x bfloat> [[VD]], <vscale x 4 x bfloat> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1_mu(vbool16_t vm, vbfloat16m1_t vd, vbfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m1_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x bfloat> [[VD:%.*]], <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv8bf16.i64(<vscale x 8 x bfloat> [[VD]], <vscale x 8 x bfloat> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2_mu(vbool8_t vm, vbfloat16m2_t vd, vbfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m2_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4_mu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x bfloat> [[VD:%.*]], <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv16bf16.i64(<vscale x 16 x bfloat> [[VD]], <vscale x 16 x bfloat> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4_mu(vbool4_t vm, vbfloat16m4_t vd, vbfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m4_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8_mu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x bfloat> [[VD:%.*]], <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv32bf16.i64(<vscale x 32 x bfloat> [[VD]], <vscale x 32 x bfloat> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8_mu(vbool2_t vm, vbfloat16m8_t vd, vbfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_v_bf16m8_mu(vm, vd, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexpa_v.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexpa_v.c new file mode 100644 index 0000000..b687026 --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexpa_v.c @@ -0,0 +1,448 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 4 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64f -target-feature +zvfh \ +// RUN: -target-feature +xsfvfexpa -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4_tu( +// CHECK-RV64-SAME: <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4_tu(vfloat16mf4_t vd, vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16mf4_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2_tu( +// CHECK-RV64-SAME: <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2_tu(vfloat16mf2_t vd, vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16mf2_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1_tu( +// CHECK-RV64-SAME: <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1_tu(vfloat16m1_t vd, vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m1_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2_tu( +// CHECK-RV64-SAME: <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2_tu(vfloat16m2_t vd, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m2_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4_tu( +// CHECK-RV64-SAME: <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4_tu(vfloat16m4_t vd, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m4_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8_tu( +// CHECK-RV64-SAME: <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8_tu(vfloat16m8_t vd, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m8_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2_tu( +// CHECK-RV64-SAME: <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2_tu(vfloat32mf2_t vd, vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32mf2_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1_tu( +// CHECK-RV64-SAME: <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1_tu(vfloat32m1_t vd, vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m1_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2_tu( +// CHECK-RV64-SAME: <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2_tu(vfloat32m2_t vd, vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m2_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4_tu( +// CHECK-RV64-SAME: <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4_tu(vfloat32m4_t vd, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m4_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8_tu( +// CHECK-RV64-SAME: <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8_tu(vfloat32m8_t vd, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m8_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16mf4_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16mf2_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m1_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m2_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4_tum( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m4_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8_tum( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m8_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2_tum(vbool64_t vm, vfloat32mf2_t vd, vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32mf2_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1_tum(vbool32_t vm, vfloat32m1_t vd, vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m1_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2_tum(vbool16_t vm, vfloat32m2_t vd, vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m2_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4_tum(vbool8_t vm, vfloat32m4_t vd, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m4_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8_tum( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8_tum(vbool4_t vm, vfloat32m8_t vd, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m8_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16mf4_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16mf2_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m1_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m2_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4_tumu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m4_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8_tumu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m8_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2_tumu(vbool64_t vm, vfloat32mf2_t vd, vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32mf2_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1_tumu(vbool32_t vm, vfloat32m1_t vd, vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m1_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2_tumu(vbool16_t vm, vfloat32m2_t vd, vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m2_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4_tumu(vbool8_t vm, vfloat32m4_t vd, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m4_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8_tumu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8_tumu(vbool4_t vm, vfloat32m8_t vd, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m8_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16mf4_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16mf2_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m1_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m2_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4_mu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m4_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8_mu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f16m8_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2_mu(vbool64_t vm, vfloat32mf2_t vd, vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32mf2_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1_mu(vbool32_t vm, vfloat32m1_t vd, vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m1_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2_mu(vbool16_t vm, vfloat32m2_t vd, vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m2_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4_mu(vbool8_t vm, vfloat32m4_t vd, vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m4_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8_mu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8_mu(vbool4_t vm, vfloat32m8_t vd, vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f32m8_mu(vm, vd, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexpa_v_64.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexpa_v_64.c new file mode 100644 index 0000000..8638dc2 --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/non-overloaded/sf_vfexpa_v_64.c @@ -0,0 +1,167 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 4 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +xsfvfexpa64e \ +// RUN: -disable-O0-optnone -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1_tu( +// CHECK-RV64-SAME: <vscale x 1 x double> [[VD:%.*]], <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.nxv1f64.i64(<vscale x 1 x double> [[VD]], <vscale x 1 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1_tu(vfloat64m1_t vd, vfloat64m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m1_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2_tu( +// CHECK-RV64-SAME: <vscale x 2 x double> [[VD:%.*]], <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.nxv2f64.i64(<vscale x 2 x double> [[VD]], <vscale x 2 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2_tu(vfloat64m2_t vd, vfloat64m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m2_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4_tu( +// CHECK-RV64-SAME: <vscale x 4 x double> [[VD:%.*]], <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.nxv4f64.i64(<vscale x 4 x double> [[VD]], <vscale x 4 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4_tu(vfloat64m4_t vd, vfloat64m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m4_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8_tu( +// CHECK-RV64-SAME: <vscale x 8 x double> [[VD:%.*]], <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.nxv8f64.i64(<vscale x 8 x double> [[VD]], <vscale x 8 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8_tu(vfloat64m8_t vd, vfloat64m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m8_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x double> [[VD:%.*]], <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.mask.nxv1f64.i64(<vscale x 1 x double> [[VD]], <vscale x 1 x double> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1_tum(vbool64_t vm, vfloat64m1_t vd, vfloat64m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m1_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x double> [[VD:%.*]], <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.mask.nxv2f64.i64(<vscale x 2 x double> [[VD]], <vscale x 2 x double> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2_tum(vbool32_t vm, vfloat64m2_t vd, vfloat64m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m2_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x double> [[VD:%.*]], <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.mask.nxv4f64.i64(<vscale x 4 x double> [[VD]], <vscale x 4 x double> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4_tum(vbool16_t vm, vfloat64m4_t vd, vfloat64m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m4_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x double> [[VD:%.*]], <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.mask.nxv8f64.i64(<vscale x 8 x double> [[VD]], <vscale x 8 x double> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8_tum(vbool8_t vm, vfloat64m8_t vd, vfloat64m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m8_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x double> [[VD:%.*]], <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.mask.nxv1f64.i64(<vscale x 1 x double> [[VD]], <vscale x 1 x double> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1_tumu(vbool64_t vm, vfloat64m1_t vd, vfloat64m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m1_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x double> [[VD:%.*]], <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.mask.nxv2f64.i64(<vscale x 2 x double> [[VD]], <vscale x 2 x double> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2_tumu(vbool32_t vm, vfloat64m2_t vd, vfloat64m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m2_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x double> [[VD:%.*]], <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.mask.nxv4f64.i64(<vscale x 4 x double> [[VD]], <vscale x 4 x double> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4_tumu(vbool16_t vm, vfloat64m4_t vd, vfloat64m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m4_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x double> [[VD:%.*]], <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.mask.nxv8f64.i64(<vscale x 8 x double> [[VD]], <vscale x 8 x double> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8_tumu(vbool8_t vm, vfloat64m8_t vd, vfloat64m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m8_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x double> [[VD:%.*]], <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.mask.nxv1f64.i64(<vscale x 1 x double> [[VD]], <vscale x 1 x double> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1_mu(vbool64_t vm, vfloat64m1_t vd, vfloat64m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m1_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x double> [[VD:%.*]], <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.mask.nxv2f64.i64(<vscale x 2 x double> [[VD]], <vscale x 2 x double> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2_mu(vbool32_t vm, vfloat64m2_t vd, vfloat64m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m2_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x double> [[VD:%.*]], <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.mask.nxv4f64.i64(<vscale x 4 x double> [[VD]], <vscale x 4 x double> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4_mu(vbool16_t vm, vfloat64m4_t vd, vfloat64m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m4_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x double> [[VD:%.*]], <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.mask.nxv8f64.i64(<vscale x 8 x double> [[VD]], <vscale x 8 x double> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8_mu(vbool8_t vm, vfloat64m8_t vd, vfloat64m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_v_f64m8_mu(vm, vd, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexp_v_16.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexp_v_16.c new file mode 100644 index 0000000..4ceeb7b --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexp_v_16.c @@ -0,0 +1,261 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zvfh \ +// RUN: -target-feature +xsfvfexp16e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2_tu( +// CHECK-RV64-SAME: <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2_tu(vfloat16mf2_t vd, vfloat16mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1_tu( +// CHECK-RV64-SAME: <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1_tu(vfloat16m1_t vd, vfloat16m1_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2_tu( +// CHECK-RV64-SAME: <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2_tu(vfloat16m2_t vd, vfloat16m2_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4_tu( +// CHECK-RV64-SAME: <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4_tu(vfloat16m4_t vd, vfloat16m4_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8_tu( +// CHECK-RV64-SAME: <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8_tu(vfloat16m8_t vd, vfloat16m8_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexp_v_f16mf4_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexp.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexp_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, + vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, + vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, + vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, + vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4_tum( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, + vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8_tum( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, + vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexp_v_f16mf4_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexp.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexp_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, + vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, + vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, + vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, + vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4_tumu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, + vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8_tumu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, + vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexp_v_f16mf4_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexp.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexp_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, + vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexp_v_f16mf2_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexp.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexp_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, + vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexp_v_f16m1_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexp.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexp_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, + vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexp_v_f16m2_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexp.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexp_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, + vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexp_v_f16m4_mu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexp.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexp_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, + vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexp_v_f16m8_mu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexp.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexp_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, + vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexp_v_32.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexp_v_32.c new file mode 100644 index 0000000..e08d6c5b --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexp_v_32.c @@ -0,0 +1,228 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zve32f \ +// RUN: -target-feature +xsfvfexp32e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2_tu( +// CHECK-RV64-SAME: <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2_tu(vfloat32mf2_t vd, vfloat32mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1_tu( +// CHECK-RV64-SAME: <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1_tu(vfloat32m1_t vd, vfloat32m1_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2_tu( +// CHECK-RV64-SAME: <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2_tu(vfloat32m2_t vd, vfloat32m2_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4_tu( +// CHECK-RV64-SAME: <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4_tu(vfloat32m4_t vd, vfloat32m4_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8_tu( +// CHECK-RV64-SAME: <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8_tu(vfloat32m8_t vd, vfloat32m8_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2_tum(vbool64_t vm, vfloat32mf2_t vd, + vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1_tum(vbool32_t vm, vfloat32m1_t vd, + vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2_tum(vbool16_t vm, vfloat32m2_t vd, + vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4_tum(vbool8_t vm, vfloat32m4_t vd, + vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8_tum( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8_tum(vbool4_t vm, vfloat32m8_t vd, + vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2_tumu(vbool64_t vm, vfloat32mf2_t vd, + vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1_tumu(vbool32_t vm, vfloat32m1_t vd, + vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2_tumu(vbool16_t vm, vfloat32m2_t vd, + vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4_tumu(vbool8_t vm, vfloat32m4_t vd, + vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8_tumu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8_tumu(vbool4_t vm, vfloat32m8_t vd, + vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexp_v_f32mf2_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexp.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexp_v_f32mf2_mu(vbool64_t vm, vfloat32mf2_t vd, + vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexp_v_f32m1_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexp.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexp_v_f32m1_mu(vbool32_t vm, vfloat32m1_t vd, + vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexp_v_f32m2_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexp.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexp_v_f32m2_mu(vbool16_t vm, vfloat32m2_t vd, + vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexp_v_f32m4_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexp.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexp_v_f32m4_mu(vbool8_t vm, vfloat32m4_t vd, + vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexp_v_f32m8_mu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexp.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexp_v_f32m8_mu(vbool4_t vm, vfloat32m8_t vd, + vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexp_v_bf.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexp_v_bf.c new file mode 100644 index 0000000..14570d4 --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexp_v_bf.c @@ -0,0 +1,272 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 5 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64x -target-feature +zve32f \ +// RUN: -target-feature +zvfbfmin -target-feature +xsfvfbfexp16e -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4_tu( +// CHECK-RV64-SAME: <vscale x 1 x bfloat> [[VD:%.*]], <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.nxv1bf16.i64(<vscale x 1 x bfloat> [[VD]], <vscale x 1 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4_tu(vbfloat16mf4_t vd, vbfloat16mf4_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2_tu( +// CHECK-RV64-SAME: <vscale x 2 x bfloat> [[VD:%.*]], <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.nxv2bf16.i64(<vscale x 2 x bfloat> [[VD]], <vscale x 2 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2_tu(vbfloat16mf2_t vd, vbfloat16mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1_tu( +// CHECK-RV64-SAME: <vscale x 4 x bfloat> [[VD:%.*]], <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.nxv4bf16.i64(<vscale x 4 x bfloat> [[VD]], <vscale x 4 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1_tu(vbfloat16m1_t vd, vbfloat16m1_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2_tu( +// CHECK-RV64-SAME: <vscale x 8 x bfloat> [[VD:%.*]], <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.nxv8bf16.i64(<vscale x 8 x bfloat> [[VD]], <vscale x 8 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2_tu(vbfloat16m2_t vd, vbfloat16m2_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4_tu( +// CHECK-RV64-SAME: <vscale x 16 x bfloat> [[VD:%.*]], <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.nxv16bf16.i64(<vscale x 16 x bfloat> [[VD]], <vscale x 16 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4_tu(vbfloat16m4_t vd, vbfloat16m4_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8_tu( +// CHECK-RV64-SAME: <vscale x 32 x bfloat> [[VD:%.*]], <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.nxv32bf16.i64(<vscale x 32 x bfloat> [[VD]], <vscale x 32 x bfloat> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8_tu(vbfloat16m8_t vd, vbfloat16m8_t vs2, + size_t vl) { + return __riscv_sf_vfexp_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x bfloat> [[VD:%.*]], <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv1bf16.i64(<vscale x 1 x bfloat> [[VD]], <vscale x 1 x bfloat> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4_tum(vbool64_t vm, vbfloat16mf4_t vd, + vbfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x bfloat> [[VD:%.*]], <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv2bf16.i64(<vscale x 2 x bfloat> [[VD]], <vscale x 2 x bfloat> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2_tum(vbool32_t vm, vbfloat16mf2_t vd, + vbfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x bfloat> [[VD:%.*]], <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv4bf16.i64(<vscale x 4 x bfloat> [[VD]], <vscale x 4 x bfloat> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1_tum(vbool16_t vm, vbfloat16m1_t vd, + vbfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x bfloat> [[VD:%.*]], <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv8bf16.i64(<vscale x 8 x bfloat> [[VD]], <vscale x 8 x bfloat> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2_tum(vbool8_t vm, vbfloat16m2_t vd, + vbfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4_tum( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x bfloat> [[VD:%.*]], <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv16bf16.i64(<vscale x 16 x bfloat> [[VD]], <vscale x 16 x bfloat> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4_tum(vbool4_t vm, vbfloat16m4_t vd, + vbfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8_tum( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x bfloat> [[VD:%.*]], <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv32bf16.i64(<vscale x 32 x bfloat> [[VD]], <vscale x 32 x bfloat> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8_tum(vbool2_t vm, vbfloat16m8_t vd, + vbfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x bfloat> [[VD:%.*]], <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv1bf16.i64(<vscale x 1 x bfloat> [[VD]], <vscale x 1 x bfloat> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4_tumu(vbool64_t vm, vbfloat16mf4_t vd, + vbfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x bfloat> [[VD:%.*]], <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv2bf16.i64(<vscale x 2 x bfloat> [[VD]], <vscale x 2 x bfloat> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2_tumu(vbool32_t vm, vbfloat16mf2_t vd, + vbfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x bfloat> [[VD:%.*]], <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv4bf16.i64(<vscale x 4 x bfloat> [[VD]], <vscale x 4 x bfloat> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1_tumu(vbool16_t vm, vbfloat16m1_t vd, + vbfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x bfloat> [[VD:%.*]], <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv8bf16.i64(<vscale x 8 x bfloat> [[VD]], <vscale x 8 x bfloat> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2_tumu(vbool8_t vm, vbfloat16m2_t vd, + vbfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4_tumu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x bfloat> [[VD:%.*]], <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv16bf16.i64(<vscale x 16 x bfloat> [[VD]], <vscale x 16 x bfloat> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4_tumu(vbool4_t vm, vbfloat16m4_t vd, + vbfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8_tumu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x bfloat> [[VD:%.*]], <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv32bf16.i64(<vscale x 32 x bfloat> [[VD]], <vscale x 32 x bfloat> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8_tumu(vbool2_t vm, vbfloat16m8_t vd, + vbfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x bfloat> @test_sf_vfexp_v_bf16mf4_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x bfloat> [[VD:%.*]], <vscale x 1 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv1bf16.i64(<vscale x 1 x bfloat> [[VD]], <vscale x 1 x bfloat> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x bfloat> [[TMP0]] +// +vbfloat16mf4_t test_sf_vfexp_v_bf16mf4_mu(vbool64_t vm, vbfloat16mf4_t vd, + vbfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x bfloat> @test_sf_vfexp_v_bf16mf2_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x bfloat> [[VD:%.*]], <vscale x 2 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv2bf16.i64(<vscale x 2 x bfloat> [[VD]], <vscale x 2 x bfloat> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x bfloat> [[TMP0]] +// +vbfloat16mf2_t test_sf_vfexp_v_bf16mf2_mu(vbool32_t vm, vbfloat16mf2_t vd, + vbfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x bfloat> @test_sf_vfexp_v_bf16m1_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x bfloat> [[VD:%.*]], <vscale x 4 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv4bf16.i64(<vscale x 4 x bfloat> [[VD]], <vscale x 4 x bfloat> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x bfloat> [[TMP0]] +// +vbfloat16m1_t test_sf_vfexp_v_bf16m1_mu(vbool16_t vm, vbfloat16m1_t vd, + vbfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x bfloat> @test_sf_vfexp_v_bf16m2_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x bfloat> [[VD:%.*]], <vscale x 8 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv8bf16.i64(<vscale x 8 x bfloat> [[VD]], <vscale x 8 x bfloat> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x bfloat> [[TMP0]] +// +vbfloat16m2_t test_sf_vfexp_v_bf16m2_mu(vbool8_t vm, vbfloat16m2_t vd, + vbfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x bfloat> @test_sf_vfexp_v_bf16m4_mu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x bfloat> [[VD:%.*]], <vscale x 16 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv16bf16.i64(<vscale x 16 x bfloat> [[VD]], <vscale x 16 x bfloat> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 16 x bfloat> [[TMP0]] +// +vbfloat16m4_t test_sf_vfexp_v_bf16m4_mu(vbool4_t vm, vbfloat16m4_t vd, + vbfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x bfloat> @test_sf_vfexp_v_bf16m8_mu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x bfloat> [[VD:%.*]], <vscale x 32 x bfloat> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: [[ENTRY:.*:]] +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x bfloat> @llvm.riscv.sf.vfexp.mask.nxv32bf16.i64(<vscale x 32 x bfloat> [[VD]], <vscale x 32 x bfloat> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 32 x bfloat> [[TMP0]] +// +vbfloat16m8_t test_sf_vfexp_v_bf16m8_mu(vbool2_t vm, vbfloat16m8_t vd, + vbfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexp_mu(vm, vd, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexpa_v.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexpa_v.c new file mode 100644 index 0000000..4ac5cfc --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexpa_v.c @@ -0,0 +1,492 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 4 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +zve64f -target-feature +zvfh \ +// RUN: -target-feature +xsfvfexpa -disable-O0-optnone \ +// RUN: -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4_tu( +// CHECK-RV64-SAME: <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4_tu(vfloat16mf4_t vd, vfloat16mf4_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2_tu( +// CHECK-RV64-SAME: <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2_tu(vfloat16mf2_t vd, vfloat16mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1_tu( +// CHECK-RV64-SAME: <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1_tu(vfloat16m1_t vd, vfloat16m1_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2_tu( +// CHECK-RV64-SAME: <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2_tu(vfloat16m2_t vd, vfloat16m2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4_tu( +// CHECK-RV64-SAME: <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4_tu(vfloat16m4_t vd, vfloat16m4_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8_tu( +// CHECK-RV64-SAME: <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8_tu(vfloat16m8_t vd, vfloat16m8_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2_tu( +// CHECK-RV64-SAME: <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2_tu(vfloat32mf2_t vd, vfloat32mf2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1_tu( +// CHECK-RV64-SAME: <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1_tu(vfloat32m1_t vd, vfloat32m1_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2_tu( +// CHECK-RV64-SAME: <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2_tu(vfloat32m2_t vd, vfloat32m2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4_tu( +// CHECK-RV64-SAME: <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4_tu(vfloat32m4_t vd, vfloat32m4_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8_tu( +// CHECK-RV64-SAME: <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8_tu(vfloat32m8_t vd, vfloat32m8_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4_tum(vbool64_t vm, vfloat16mf4_t vd, + vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2_tum(vbool32_t vm, vfloat16mf2_t vd, + vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1_tum(vbool16_t vm, vfloat16m1_t vd, + vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2_tum(vbool8_t vm, vfloat16m2_t vd, + vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4_tum( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4_tum(vbool4_t vm, vfloat16m4_t vd, + vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8_tum( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8_tum(vbool2_t vm, vfloat16m8_t vd, + vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2_tum(vbool64_t vm, vfloat32mf2_t vd, + vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1_tum(vbool32_t vm, vfloat32m1_t vd, + vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2_tum(vbool16_t vm, vfloat32m2_t vd, + vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4_tum(vbool8_t vm, vfloat32m4_t vd, + vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8_tum( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8_tum(vbool4_t vm, vfloat32m8_t vd, + vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4_tumu(vbool64_t vm, vfloat16mf4_t vd, + vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2_tumu(vbool32_t vm, vfloat16mf2_t vd, + vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1_tumu(vbool16_t vm, vfloat16m1_t vd, + vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2_tumu(vbool8_t vm, vfloat16m2_t vd, + vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4_tumu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4_tumu(vbool4_t vm, vfloat16m4_t vd, + vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8_tumu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8_tumu(vbool2_t vm, vfloat16m8_t vd, + vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2_tumu(vbool64_t vm, vfloat32mf2_t vd, + vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1_tumu(vbool32_t vm, vfloat32m1_t vd, + vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2_tumu(vbool16_t vm, vfloat32m2_t vd, + vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4_tumu(vbool8_t vm, vfloat32m4_t vd, + vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8_tumu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8_tumu(vbool4_t vm, vfloat32m8_t vd, + vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x half> @test_sf_vfexpa_v_f16mf4_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x half> [[VD:%.*]], <vscale x 1 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x half> @llvm.riscv.sf.vfexpa.mask.nxv1f16.i64(<vscale x 1 x half> [[VD]], <vscale x 1 x half> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x half> [[TMP0]] +// +vfloat16mf4_t test_sf_vfexpa_v_f16mf4_mu(vbool64_t vm, vfloat16mf4_t vd, + vfloat16mf4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x half> @test_sf_vfexpa_v_f16mf2_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x half> [[VD:%.*]], <vscale x 2 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x half> @llvm.riscv.sf.vfexpa.mask.nxv2f16.i64(<vscale x 2 x half> [[VD]], <vscale x 2 x half> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x half> [[TMP0]] +// +vfloat16mf2_t test_sf_vfexpa_v_f16mf2_mu(vbool32_t vm, vfloat16mf2_t vd, + vfloat16mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x half> @test_sf_vfexpa_v_f16m1_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x half> [[VD:%.*]], <vscale x 4 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x half> @llvm.riscv.sf.vfexpa.mask.nxv4f16.i64(<vscale x 4 x half> [[VD]], <vscale x 4 x half> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x half> [[TMP0]] +// +vfloat16m1_t test_sf_vfexpa_v_f16m1_mu(vbool16_t vm, vfloat16m1_t vd, + vfloat16m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x half> @test_sf_vfexpa_v_f16m2_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x half> [[VD:%.*]], <vscale x 8 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x half> @llvm.riscv.sf.vfexpa.mask.nxv8f16.i64(<vscale x 8 x half> [[VD]], <vscale x 8 x half> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x half> [[TMP0]] +// +vfloat16m2_t test_sf_vfexpa_v_f16m2_mu(vbool8_t vm, vfloat16m2_t vd, + vfloat16m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x half> @test_sf_vfexpa_v_f16m4_mu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x half> [[VD:%.*]], <vscale x 16 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x half> @llvm.riscv.sf.vfexpa.mask.nxv16f16.i64(<vscale x 16 x half> [[VD]], <vscale x 16 x half> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 16 x half> [[TMP0]] +// +vfloat16m4_t test_sf_vfexpa_v_f16m4_mu(vbool4_t vm, vfloat16m4_t vd, + vfloat16m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 32 x half> @test_sf_vfexpa_v_f16m8_mu( +// CHECK-RV64-SAME: <vscale x 32 x i1> [[VM:%.*]], <vscale x 32 x half> [[VD:%.*]], <vscale x 32 x half> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 32 x half> @llvm.riscv.sf.vfexpa.mask.nxv32f16.i64(<vscale x 32 x half> [[VD]], <vscale x 32 x half> [[VS2]], <vscale x 32 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 32 x half> [[TMP0]] +// +vfloat16m8_t test_sf_vfexpa_v_f16m8_mu(vbool2_t vm, vfloat16m8_t vd, + vfloat16m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x float> @test_sf_vfexpa_v_f32mf2_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x float> [[VD:%.*]], <vscale x 1 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x float> @llvm.riscv.sf.vfexpa.mask.nxv1f32.i64(<vscale x 1 x float> [[VD]], <vscale x 1 x float> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x float> [[TMP0]] +// +vfloat32mf2_t test_sf_vfexpa_v_f32mf2_mu(vbool64_t vm, vfloat32mf2_t vd, + vfloat32mf2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x float> @test_sf_vfexpa_v_f32m1_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x float> [[VD:%.*]], <vscale x 2 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x float> @llvm.riscv.sf.vfexpa.mask.nxv2f32.i64(<vscale x 2 x float> [[VD]], <vscale x 2 x float> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x float> [[TMP0]] +// +vfloat32m1_t test_sf_vfexpa_v_f32m1_mu(vbool32_t vm, vfloat32m1_t vd, + vfloat32m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x float> @test_sf_vfexpa_v_f32m2_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x float> [[VD:%.*]], <vscale x 4 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x float> @llvm.riscv.sf.vfexpa.mask.nxv4f32.i64(<vscale x 4 x float> [[VD]], <vscale x 4 x float> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x float> [[TMP0]] +// +vfloat32m2_t test_sf_vfexpa_v_f32m2_mu(vbool16_t vm, vfloat32m2_t vd, + vfloat32m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x float> @test_sf_vfexpa_v_f32m4_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x float> [[VD:%.*]], <vscale x 8 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x float> @llvm.riscv.sf.vfexpa.mask.nxv8f32.i64(<vscale x 8 x float> [[VD]], <vscale x 8 x float> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x float> [[TMP0]] +// +vfloat32m4_t test_sf_vfexpa_v_f32m4_mu(vbool8_t vm, vfloat32m4_t vd, + vfloat32m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 16 x float> @test_sf_vfexpa_v_f32m8_mu( +// CHECK-RV64-SAME: <vscale x 16 x i1> [[VM:%.*]], <vscale x 16 x float> [[VD:%.*]], <vscale x 16 x float> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 16 x float> @llvm.riscv.sf.vfexpa.mask.nxv16f32.i64(<vscale x 16 x float> [[VD]], <vscale x 16 x float> [[VS2]], <vscale x 16 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 16 x float> [[TMP0]] +// +vfloat32m8_t test_sf_vfexpa_v_f32m8_mu(vbool4_t vm, vfloat32m8_t vd, + vfloat32m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} diff --git a/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexpa_v_64.c b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexpa_v_64.c new file mode 100644 index 0000000..d0faaee5 --- /dev/null +++ b/clang/test/CodeGen/RISCV/rvv-intrinsics-sifive/policy/overloaded/sf_vfexpa_v_64.c @@ -0,0 +1,183 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 4 +// REQUIRES: riscv-registered-target +// RUN: %clang_cc1 -triple riscv64 -target-feature +xsfvfexpa64e \ +// RUN: -disable-O0-optnone -emit-llvm %s -o - | opt -S -passes=mem2reg | \ +// RUN: FileCheck --check-prefix=CHECK-RV64 %s + +#include <sifive_vector.h> + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1_tu( +// CHECK-RV64-SAME: <vscale x 1 x double> [[VD:%.*]], <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.nxv1f64.i64(<vscale x 1 x double> [[VD]], <vscale x 1 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1_tu(vfloat64m1_t vd, vfloat64m1_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2_tu( +// CHECK-RV64-SAME: <vscale x 2 x double> [[VD:%.*]], <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.nxv2f64.i64(<vscale x 2 x double> [[VD]], <vscale x 2 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2_tu(vfloat64m2_t vd, vfloat64m2_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4_tu( +// CHECK-RV64-SAME: <vscale x 4 x double> [[VD:%.*]], <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.nxv4f64.i64(<vscale x 4 x double> [[VD]], <vscale x 4 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4_tu(vfloat64m4_t vd, vfloat64m4_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8_tu( +// CHECK-RV64-SAME: <vscale x 8 x double> [[VD:%.*]], <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.nxv8f64.i64(<vscale x 8 x double> [[VD]], <vscale x 8 x double> [[VS2]], i64 [[VL]]) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8_tu(vfloat64m8_t vd, vfloat64m8_t vs2, + size_t vl) { + return __riscv_sf_vfexpa_tu(vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1_tum( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x double> [[VD:%.*]], <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.mask.nxv1f64.i64(<vscale x 1 x double> [[VD]], <vscale x 1 x double> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1_tum(vbool64_t vm, vfloat64m1_t vd, + vfloat64m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2_tum( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x double> [[VD:%.*]], <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.mask.nxv2f64.i64(<vscale x 2 x double> [[VD]], <vscale x 2 x double> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2_tum(vbool32_t vm, vfloat64m2_t vd, + vfloat64m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4_tum( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x double> [[VD:%.*]], <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.mask.nxv4f64.i64(<vscale x 4 x double> [[VD]], <vscale x 4 x double> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4_tum(vbool16_t vm, vfloat64m4_t vd, + vfloat64m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8_tum( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x double> [[VD:%.*]], <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.mask.nxv8f64.i64(<vscale x 8 x double> [[VD]], <vscale x 8 x double> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 2) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8_tum(vbool8_t vm, vfloat64m8_t vd, + vfloat64m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tum(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1_tumu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x double> [[VD:%.*]], <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.mask.nxv1f64.i64(<vscale x 1 x double> [[VD]], <vscale x 1 x double> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1_tumu(vbool64_t vm, vfloat64m1_t vd, + vfloat64m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2_tumu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x double> [[VD:%.*]], <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.mask.nxv2f64.i64(<vscale x 2 x double> [[VD]], <vscale x 2 x double> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2_tumu(vbool32_t vm, vfloat64m2_t vd, + vfloat64m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4_tumu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x double> [[VD:%.*]], <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.mask.nxv4f64.i64(<vscale x 4 x double> [[VD]], <vscale x 4 x double> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4_tumu(vbool16_t vm, vfloat64m4_t vd, + vfloat64m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8_tumu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x double> [[VD:%.*]], <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.mask.nxv8f64.i64(<vscale x 8 x double> [[VD]], <vscale x 8 x double> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 0) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8_tumu(vbool8_t vm, vfloat64m8_t vd, + vfloat64m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_tumu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 1 x double> @test_sf_vfexpa_v_f64m1_mu( +// CHECK-RV64-SAME: <vscale x 1 x i1> [[VM:%.*]], <vscale x 1 x double> [[VD:%.*]], <vscale x 1 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 1 x double> @llvm.riscv.sf.vfexpa.mask.nxv1f64.i64(<vscale x 1 x double> [[VD]], <vscale x 1 x double> [[VS2]], <vscale x 1 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 1 x double> [[TMP0]] +// +vfloat64m1_t test_sf_vfexpa_v_f64m1_mu(vbool64_t vm, vfloat64m1_t vd, + vfloat64m1_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 2 x double> @test_sf_vfexpa_v_f64m2_mu( +// CHECK-RV64-SAME: <vscale x 2 x i1> [[VM:%.*]], <vscale x 2 x double> [[VD:%.*]], <vscale x 2 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 2 x double> @llvm.riscv.sf.vfexpa.mask.nxv2f64.i64(<vscale x 2 x double> [[VD]], <vscale x 2 x double> [[VS2]], <vscale x 2 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 2 x double> [[TMP0]] +// +vfloat64m2_t test_sf_vfexpa_v_f64m2_mu(vbool32_t vm, vfloat64m2_t vd, + vfloat64m2_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 4 x double> @test_sf_vfexpa_v_f64m4_mu( +// CHECK-RV64-SAME: <vscale x 4 x i1> [[VM:%.*]], <vscale x 4 x double> [[VD:%.*]], <vscale x 4 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 4 x double> @llvm.riscv.sf.vfexpa.mask.nxv4f64.i64(<vscale x 4 x double> [[VD]], <vscale x 4 x double> [[VS2]], <vscale x 4 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 4 x double> [[TMP0]] +// +vfloat64m4_t test_sf_vfexpa_v_f64m4_mu(vbool16_t vm, vfloat64m4_t vd, + vfloat64m4_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} + +// CHECK-RV64-LABEL: define dso_local <vscale x 8 x double> @test_sf_vfexpa_v_f64m8_mu( +// CHECK-RV64-SAME: <vscale x 8 x i1> [[VM:%.*]], <vscale x 8 x double> [[VD:%.*]], <vscale x 8 x double> [[VS2:%.*]], i64 noundef [[VL:%.*]]) #[[ATTR0]] { +// CHECK-RV64-NEXT: entry: +// CHECK-RV64-NEXT: [[TMP0:%.*]] = call <vscale x 8 x double> @llvm.riscv.sf.vfexpa.mask.nxv8f64.i64(<vscale x 8 x double> [[VD]], <vscale x 8 x double> [[VS2]], <vscale x 8 x i1> [[VM]], i64 [[VL]], i64 1) +// CHECK-RV64-NEXT: ret <vscale x 8 x double> [[TMP0]] +// +vfloat64m8_t test_sf_vfexpa_v_f64m8_mu(vbool8_t vm, vfloat64m8_t vd, + vfloat64m8_t vs2, size_t vl) { + return __riscv_sf_vfexpa_mu(vm, vd, vs2, vl); +} diff --git a/clang/test/CodeGen/SystemZ/builtins-systemz-zvector.c b/clang/test/CodeGen/SystemZ/builtins-systemz-zvector.c index d5d15b4d..35fde87 100644 --- a/clang/test/CodeGen/SystemZ/builtins-systemz-zvector.c +++ b/clang/test/CodeGen/SystemZ/builtins-systemz-zvector.c @@ -3584,13 +3584,13 @@ void test_integer(void) { // CHECK-ASM: vsrlb vsc = vec_abs(vsc); - // CHECK-ASM: vlcb + // CHECK-ASM: vlpb vss = vec_abs(vss); - // CHECK-ASM: vlch + // CHECK-ASM: vlph vsi = vec_abs(vsi); - // CHECK-ASM: vlcf + // CHECK-ASM: vlpf vsl = vec_abs(vsl); - // CHECK-ASM: vlcg + // CHECK-ASM: vlpg vsc = vec_max(vsc, vsc); // CHECK-ASM: vmxb diff --git a/clang/test/CodeGen/SystemZ/builtins-systemz-zvector5.c b/clang/test/CodeGen/SystemZ/builtins-systemz-zvector5.c index 6ee9e1e..cd0fafd 100644 --- a/clang/test/CodeGen/SystemZ/builtins-systemz-zvector5.c +++ b/clang/test/CodeGen/SystemZ/builtins-systemz-zvector5.c @@ -246,7 +246,7 @@ void test_integer(void) { // CHECK-ASM: vctzq vslll = vec_abs(vslll); - // CHECK-ASM: vlcq + // CHECK-ASM: vlpq vslll = vec_avg(vslll, vslll); // CHECK: call i128 @llvm.s390.vavgq(i128 %{{.*}}, i128 %{{.*}}) diff --git a/clang/test/CodeGen/X86/math-builtins.c b/clang/test/CodeGen/X86/math-builtins.c index a56f8ba..c7cd9ff 100644 --- a/clang/test/CodeGen/X86/math-builtins.c +++ b/clang/test/CodeGen/X86/math-builtins.c @@ -118,36 +118,36 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { __builtin_copysign(f,f); __builtin_copysignf(f,f); __builtin_copysignl(f,f); __builtin_copysignf128(f,f); -// NO__ERRNO: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.copysign.f128(fp128, fp128) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC:#[0-9]+]] -// HAS_ERRNO: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare fp128 @llvm.copysign.f128(fp128, fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC2:#[0-9]+]] +// NO__ERRNO: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.copysign.f128(fp128, fp128) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC2:#[0-9]+]] +// HAS_ERRNO: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare fp128 @llvm.copysign.f128(fp128, fp128) [[READNONE_INTRINSIC2]] __builtin_fabs(f); __builtin_fabsf(f); __builtin_fabsl(f); __builtin_fabsf128(f); -// NO__ERRNO: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.fabs.f128(fp128) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare fp128 @llvm.fabs.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.fabs.f128(fp128) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare fp128 @llvm.fabs.f128(fp128) [[READNONE_INTRINSIC2]] __builtin_frexp(f,i); __builtin_frexpf(f,i); __builtin_frexpl(f,i); __builtin_frexpf128(f,i); -// NO__ERRNO: declare { double, i32 } @llvm.frexp.f64.i32(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare { float, i32 } @llvm.frexp.f32.i32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare { x86_fp80, i32 } @llvm.frexp.f80.i32(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare { fp128, i32 } @llvm.frexp.f128.i32(fp128) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare { double, i32 } @llvm.frexp.f64.i32(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare { float, i32 } @llvm.frexp.f32.i32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare { x86_fp80, i32 } @llvm.frexp.f80.i32(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare { fp128, i32 } @llvm.frexp.f128.i32(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare { double, i32 } @llvm.frexp.f64.i32(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare { float, i32 } @llvm.frexp.f32.i32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare { x86_fp80, i32 } @llvm.frexp.f80.i32(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare { fp128, i32 } @llvm.frexp.f128.i32(fp128) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare { double, i32 } @llvm.frexp.f64.i32(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare { float, i32 } @llvm.frexp.f32.i32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare { x86_fp80, i32 } @llvm.frexp.f80.i32(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare { fp128, i32 } @llvm.frexp.f128.i32(fp128) [[READNONE_INTRINSIC2]] __builtin_huge_val(); __builtin_huge_valf(); __builtin_huge_vall(); __builtin_huge_valf128(); @@ -165,10 +165,10 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { __builtin_ldexp(f,f); __builtin_ldexpf(f,f); __builtin_ldexpl(f,f); __builtin_ldexpf128(f,f); -// NO__ERRNO: declare double @llvm.ldexp.f64.i32(double, i32) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.ldexp.f32.i32(float, i32) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.ldexp.f80.i32(x86_fp80, i32) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.ldexp.f128.i32(fp128, i32) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.ldexp.f64.i32(double, i32) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.ldexp.f32.i32(float, i32) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.ldexp.f80.i32(x86_fp80, i32) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.ldexp.f128.i32(fp128, i32) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @ldexp(double noundef, i32 noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @ldexpf(float noundef, i32 noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @ldexpl(x86_fp80 noundef, i32 noundef) [[NOT_READNONE]] @@ -180,7 +180,7 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { // NO__ERRNO: declare { float, float } @llvm.modf.f32(float) [[READNONE_INTRINSIC]] // NO__ERRNO: declare { x86_fp80, x86_fp80 } @llvm.modf.f80(x86_fp80) [[READNONE_INTRINSIC]] // NO__ERRNO: declare fp128 @modff128(fp128 noundef, ptr noundef) [[NOT_READNONE:#[0-9]+]] -// HAS_ERRNO: declare { double, double } @llvm.modf.f64(double) [[READNONE_INTRINSIC]] +// HAS_ERRNO: declare { double, double } @llvm.modf.f64(double) [[READNONE_INTRINSIC:#[0-9]+]] // HAS_ERRNO: declare { float, float } @llvm.modf.f32(float) [[READNONE_INTRINSIC]] // HAS_ERRNO: declare { x86_fp80, x86_fp80 } @llvm.modf.f80(x86_fp80) [[READNONE_INTRINSIC]] // HAS_ERRNO: declare fp128 @modff128(fp128 noundef, ptr noundef) [[NOT_READNONE]] @@ -209,10 +209,10 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { __builtin_pow(f,f); __builtin_powf(f,f); __builtin_powl(f,f); __builtin_powf128(f,f); -// NO__ERRNO: declare double @llvm.pow.f64(double, double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.pow.f32(float, float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.pow.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.pow.f128(fp128, fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.pow.f64(double, double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.pow.f32(float, float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.pow.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.pow.f128(fp128, fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @pow(double noundef, double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @powf(float noundef, float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @powl(x86_fp80 noundef, x86_fp80 noundef) [[NOT_READNONE]] @@ -220,12 +220,12 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { __builtin_powi(f,f); __builtin_powif(f,f); __builtin_powil(f,f); -// NO__ERRNO: declare double @llvm.powi.f64.i32(double, i32) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.powi.f32.i32(float, i32) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.powi.f80.i32(x86_fp80, i32) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.powi.f64.i32(double, i32) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.powi.f32.i32(float, i32) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.powi.f80.i32(x86_fp80, i32) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.powi.f64.i32(double, i32) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.powi.f32.i32(float, i32) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.powi.f80.i32(x86_fp80, i32) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.powi.f64.i32(double, i32) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.powi.f32.i32(float, i32) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.powi.f80.i32(x86_fp80, i32) [[READNONE_INTRINSIC2]] /* math */ __builtin_acos(f); __builtin_acosf(f); __builtin_acosl(f); __builtin_acosf128(f); @@ -307,21 +307,21 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { __builtin_ceil(f); __builtin_ceilf(f); __builtin_ceill(f); __builtin_ceilf128(f); -// NO__ERRNO: declare double @llvm.ceil.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.ceil.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.ceil.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.ceil.f128(fp128) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.ceil.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.ceil.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.ceil.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare fp128 @llvm.ceil.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.ceil.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.ceil.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.ceil.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.ceil.f128(fp128) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.ceil.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.ceil.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.ceil.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare fp128 @llvm.ceil.f128(fp128) [[READNONE_INTRINSIC2]] __builtin_cos(f); __builtin_cosf(f); __builtin_cosl(f); __builtin_cosf128(f); -// NO__ERRNO: declare double @llvm.cos.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.cos.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.cos.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.cos.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.cos.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.cos.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.cos.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.cos.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @cos(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @cosf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @cosl(x86_fp80 noundef) [[NOT_READNONE]] @@ -362,10 +362,10 @@ __builtin_erfc(f); __builtin_erfcf(f); __builtin_erfcl(f); __builtin_ __builtin_exp(f); __builtin_expf(f); __builtin_expl(f); __builtin_expf128(f); -// NO__ERRNO: declare double @llvm.exp.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.exp.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.exp.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.exp.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.exp.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.exp.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.exp.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.exp.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @exp(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @expf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @expl(x86_fp80 noundef) [[NOT_READNONE]] @@ -373,10 +373,10 @@ __builtin_exp(f); __builtin_expf(f); __builtin_expl(f); __builtin_e __builtin_exp2(f); __builtin_exp2f(f); __builtin_exp2l(f); __builtin_exp2f128(f); -// NO__ERRNO: declare double @llvm.exp2.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.exp2.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.exp2.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.exp2.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.exp2.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.exp2.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.exp2.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.exp2.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @exp2(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @exp2f(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @exp2l(x86_fp80 noundef) [[NOT_READNONE]] @@ -384,10 +384,10 @@ __builtin_exp2(f); __builtin_exp2f(f); __builtin_exp2l(f); __builtin_ __builtin_exp10(f); __builtin_exp10f(f); __builtin_exp10l(f); __builtin_exp10f128(f); -// NO__ERRNO: declare double @llvm.exp10.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.exp10.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.exp10.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.exp10.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.exp10.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.exp10.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.exp10.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.exp10.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @exp10(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @exp10f(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @exp10l(x86_fp80 noundef) [[NOT_READNONE]] @@ -417,22 +417,22 @@ __builtin_fdim(f,f); __builtin_fdimf(f,f); __builtin_fdiml(f,f); __bu __builtin_floor(f); __builtin_floorf(f); __builtin_floorl(f); __builtin_floorf128(f); -// NO__ERRNO: declare double @llvm.floor.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.floor.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.floor.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.floor.f128(fp128) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.floor.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.floor.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.floor.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare fp128 @llvm.floor.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.floor.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.floor.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.floor.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.floor.f128(fp128) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.floor.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.floor.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.floor.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare fp128 @llvm.floor.f128(fp128) [[READNONE_INTRINSIC2]] __builtin_fma(f,f,f); __builtin_fmaf(f,f,f); __builtin_fmal(f,f,f); __builtin_fmaf128(f,f,f); __builtin_fmaf16(f,f,f); -// NO__ERRNO: declare double @llvm.fma.f64(double, double, double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.fma.f32(float, float, float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.fma.f128(fp128, fp128, fp128) [[READNONE_INTRINSIC]] -// NO__ERRONO: declare half @llvm.fma.f16(half, half, half) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.fma.f64(double, double, double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.fma.f32(float, float, float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.fma.f128(fp128, fp128, fp128) [[READNONE_INTRINSIC2]] +// NO__ERRONO: declare half @llvm.fma.f16(half, half, half) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @fma(double noundef, double noundef, double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @fmaf(float noundef, float noundef, float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @fmal(x86_fp80 noundef, x86_fp80 noundef, x86_fp80 noundef) [[NOT_READNONE]] @@ -454,25 +454,25 @@ __builtin_fma(f,f,f); __builtin_fmaf(f,f,f); __builtin_fmal(f,f,f); __builtin_fmax(f,f); __builtin_fmaxf(f,f); __builtin_fmaxl(f,f); __builtin_fmaxf128(f,f); -// NO__ERRNO: declare double @llvm.maxnum.f64(double, double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.maxnum.f32(float, float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.maxnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.maxnum.f128(fp128, fp128) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.maxnum.f64(double, double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.maxnum.f32(float, float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.maxnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare fp128 @llvm.maxnum.f128(fp128, fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.maxnum.f64(double, double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.maxnum.f32(float, float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.maxnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.maxnum.f128(fp128, fp128) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.maxnum.f64(double, double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.maxnum.f32(float, float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.maxnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare fp128 @llvm.maxnum.f128(fp128, fp128) [[READNONE_INTRINSIC2]] __builtin_fmin(f,f); __builtin_fminf(f,f); __builtin_fminl(f,f); __builtin_fminf128(f,f); -// NO__ERRNO: declare double @llvm.minnum.f64(double, double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.minnum.f128(fp128, fp128) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.minnum.f64(double, double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare fp128 @llvm.minnum.f128(fp128, fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.minnum.f64(double, double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.minnum.f128(fp128, fp128) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.minnum.f64(double, double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare fp128 @llvm.minnum.f128(fp128, fp128) [[READNONE_INTRINSIC2]] __builtin_hypot(f,f); __builtin_hypotf(f,f); __builtin_hypotl(f,f); __builtin_hypotf128(f,f); @@ -509,10 +509,10 @@ __builtin_lgamma(f); __builtin_lgammaf(f); __builtin_lgammal(f); __builti __builtin_llrint(f); __builtin_llrintf(f); __builtin_llrintl(f); __builtin_llrintf128(f); -// NO__ERRNO: declare i64 @llvm.llrint.i64.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.llrint.i64.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.llrint.i64.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.llrint.i64.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare i64 @llvm.llrint.i64.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.llrint.i64.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.llrint.i64.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.llrint.i64.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare i64 @llrint(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @llrintf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @llrintl(x86_fp80 noundef) [[NOT_READNONE]] @@ -520,10 +520,10 @@ __builtin_llrint(f); __builtin_llrintf(f); __builtin_llrintl(f); __builti __builtin_llround(f); __builtin_llroundf(f); __builtin_llroundl(f); __builtin_llroundf128(f); -// NO__ERRNO: declare i64 @llvm.llround.i64.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.llround.i64.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.llround.i64.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.llround.i64.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare i64 @llvm.llround.i64.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.llround.i64.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.llround.i64.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.llround.i64.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare i64 @llround(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @llroundf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @llroundl(x86_fp80 noundef) [[NOT_READNONE]] @@ -531,10 +531,10 @@ __builtin_llround(f); __builtin_llroundf(f); __builtin_llroundl(f); __built __builtin_log(f); __builtin_logf(f); __builtin_logl(f); __builtin_logf128(f); -// NO__ERRNO: declare double @llvm.log.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.log.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.log.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.log.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.log.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.log.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.log.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.log.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @log(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @logf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @logl(x86_fp80 noundef) [[NOT_READNONE]] @@ -542,10 +542,10 @@ __builtin_log(f); __builtin_logf(f); __builtin_logl(f); __builtin_l __builtin_log10(f); __builtin_log10f(f); __builtin_log10l(f); __builtin_log10f128(f); -// NO__ERRNO: declare double @llvm.log10.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.log10.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.log10.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.log10.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.log10.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.log10.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.log10.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.log10.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @log10(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @log10f(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @log10l(x86_fp80 noundef) [[NOT_READNONE]] @@ -564,10 +564,10 @@ __builtin_log1p(f); __builtin_log1pf(f); __builtin_log1pl(f); __builtin __builtin_log2(f); __builtin_log2f(f); __builtin_log2l(f); __builtin_log2f128(f); -// NO__ERRNO: declare double @llvm.log2.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.log2.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.log2.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.log2.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.log2.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.log2.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.log2.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.log2.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @log2(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @log2f(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @log2l(x86_fp80 noundef) [[NOT_READNONE]] @@ -586,10 +586,10 @@ __builtin_logb(f); __builtin_logbf(f); __builtin_logbl(f); __builtin_ __builtin_lrint(f); __builtin_lrintf(f); __builtin_lrintl(f); __builtin_lrintf128(f); -// NO__ERRNO: declare i64 @llvm.lrint.i64.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.lrint.i64.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.lrint.i64.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.lrint.i64.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare i64 @llvm.lrint.i64.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.lrint.i64.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.lrint.i64.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.lrint.i64.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare i64 @lrint(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @lrintf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @lrintl(x86_fp80 noundef) [[NOT_READNONE]] @@ -597,10 +597,10 @@ __builtin_lrint(f); __builtin_lrintf(f); __builtin_lrintl(f); __builtin __builtin_lround(f); __builtin_lroundf(f); __builtin_lroundl(f); __builtin_lroundf128(f); -// NO__ERRNO: declare i64 @llvm.lround.i64.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.lround.i64.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.lround.i64.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.lround.i64.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare i64 @llvm.lround.i64.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.lround.i64.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.lround.i64.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.lround.i64.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare i64 @lround(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @lroundf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @lroundl(x86_fp80 noundef) [[NOT_READNONE]] @@ -608,14 +608,14 @@ __builtin_lround(f); __builtin_lroundf(f); __builtin_lroundl(f); __built __builtin_nearbyint(f); __builtin_nearbyintf(f); __builtin_nearbyintl(f); __builtin_nearbyintf128(f); -// NO__ERRNO: declare double @llvm.nearbyint.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.nearbyint.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.nearbyint.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.nearbyint.f128(fp128) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.nearbyint.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.nearbyint.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.nearbyint.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare fp128 @llvm.nearbyint.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.nearbyint.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.nearbyint.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.nearbyint.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.nearbyint.f128(fp128) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.nearbyint.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.nearbyint.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.nearbyint.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare fp128 @llvm.nearbyint.f128(fp128) [[READNONE_INTRINSIC2]] __builtin_nextafter(f,f); __builtin_nextafterf(f,f); __builtin_nextafterl(f,f); __builtin_nextafterf128(f,f); @@ -663,25 +663,25 @@ __builtin_remquo(f,f,i); __builtin_remquof(f,f,i); __builtin_remquol(f,f,i); __ __builtin_rint(f); __builtin_rintf(f); __builtin_rintl(f); __builtin_rintf128(f); -// NO__ERRNO: declare double @llvm.rint.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.rint.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.rint.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.rint.f128(fp128) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.rint.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.rint.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.rint.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare fp128 @llvm.rint.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.rint.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.rint.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.rint.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.rint.f128(fp128) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.rint.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.rint.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.rint.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare fp128 @llvm.rint.f128(fp128) [[READNONE_INTRINSIC2]] __builtin_round(f); __builtin_roundf(f); __builtin_roundl(f); __builtin_roundf128(f); -// NO__ERRNO: declare double @llvm.round.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.round.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.round.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.round.f128(fp128) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.round.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.round.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.round.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare fp128 @llvm.round.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.round.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.round.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.round.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.round.f128(fp128) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.round.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.round.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.round.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare fp128 @llvm.round.f128(fp128) [[READNONE_INTRINSIC2]] __builtin_scalbln(f,f); __builtin_scalblnf(f,f); __builtin_scalblnl(f,f); __builtin_scalblnf128(f,f); @@ -707,10 +707,10 @@ __builtin_scalbn(f,f); __builtin_scalbnf(f,f); __builtin_scalbnl(f,f); __ __builtin_sin(f); __builtin_sinf(f); __builtin_sinl(f); __builtin_sinf128(f); -// NO__ERRNO: declare double @llvm.sin.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.sin.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.sin.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.sin.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.sin.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.sin.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.sin.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.sin.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @sin(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @sinf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @sinl(x86_fp80 noundef) [[NOT_READNONE]] @@ -747,10 +747,10 @@ __builtin_sincospi(f,d,d); __builtin_sincospif(f,fp,fp); __builtin_sincospil(f,l __builtin_sqrt(f); __builtin_sqrtf(f); __builtin_sqrtl(f); __builtin_sqrtf128(f); -// NO__ERRNO: declare double @llvm.sqrt.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.sqrt.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.sqrt.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.sqrt.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.sqrt.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.sqrt.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.sqrt.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.sqrt.f128(fp128) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @sqrt(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @sqrtf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @sqrtl(x86_fp80 noundef) [[NOT_READNONE]] @@ -791,22 +791,24 @@ __builtin_tgamma(f); __builtin_tgammaf(f); __builtin_tgammal(f); __builti __builtin_trunc(f); __builtin_truncf(f); __builtin_truncl(f); __builtin_truncf128(f); -// NO__ERRNO: declare double @llvm.trunc.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.trunc.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.trunc.f80(x86_fp80) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare fp128 @llvm.trunc.f128(fp128) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.trunc.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.trunc.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.trunc.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare fp128 @llvm.trunc.f128(fp128) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.trunc.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.trunc.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.trunc.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare fp128 @llvm.trunc.f128(fp128) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.trunc.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.trunc.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.trunc.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare fp128 @llvm.trunc.f128(fp128) [[READNONE_INTRINSIC2]] }; // NO__ERRNO: attributes [[READNONE_INTRINSIC]] = { {{.*}}memory(none){{.*}} } +// NO__ERRNO: attributes [[READNONE_INTRINSIC2]] = { {{.*}}memory(none){{.*}} } // NO__ERRNO: attributes [[NOT_READNONE]] = { nounwind {{.*}} } // NO__ERRNO: attributes [[PURE]] = { {{.*}}memory(read){{.*}} } // NO__ERRNO: attributes [[READNONE]] = { {{.*}}memory(none){{.*}} } // HAS_ERRNO: attributes [[NOT_READNONE]] = { nounwind {{.*}} } +// HAS_ERRNO: attributes [[READNONE_INTRINSIC2]] = { {{.*}}memory(none){{.*}} } // HAS_ERRNO: attributes [[READNONE_INTRINSIC]] = { {{.*}}memory(none){{.*}} } // HAS_ERRNO: attributes [[PURE]] = { {{.*}}memory(read){{.*}} } // HAS_ERRNO: attributes [[READNONE]] = { {{.*}}memory(none){{.*}} } diff --git a/clang/test/CodeGen/builtin-sqrt.c b/clang/test/CodeGen/builtin-sqrt.c index 2313a68..3ebf2ac 100644 --- a/clang/test/CodeGen/builtin-sqrt.c +++ b/clang/test/CodeGen/builtin-sqrt.c @@ -11,5 +11,5 @@ float foo(float X) { // HAS_ERRNO-NOT: attributes [[ATTR]] = {{{.*}} memory(none) // NO_ERRNO: declare float @llvm.sqrt.f32(float) [[ATTR:#[0-9]+]] -// NO_ERRNO: attributes [[ATTR]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } +// NO_ERRNO: attributes [[ATTR]] = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } diff --git a/clang/test/CodeGen/libcalls.c b/clang/test/CodeGen/libcalls.c index 1e4b06e..923719f 100644 --- a/clang/test/CodeGen/libcalls.c +++ b/clang/test/CodeGen/libcalls.c @@ -74,9 +74,9 @@ void test_fma(float a0, double a1, long double a2) { // CHECK-YES: declare float @fmaf(float noundef, float noundef, float noundef) // CHECK-YES: declare double @fma(double noundef, double noundef, double noundef) // CHECK-YES: declare x86_fp80 @fmal(x86_fp80 noundef, x86_fp80 noundef, x86_fp80 noundef) -// CHECK-NO: declare float @llvm.fma.f32(float, float, float) [[NUW_RN2:#[0-9]+]] -// CHECK-NO: declare double @llvm.fma.f64(double, double, double) [[NUW_RN2]] -// CHECK-NO: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) [[NUW_RN2]] +// CHECK-NO: declare float @llvm.fma.f32(float, float, float) [[NUW_RNI]] +// CHECK-NO: declare double @llvm.fma.f64(double, double, double) [[NUW_RNI]] +// CHECK-NO: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) [[NUW_RNI]] // Just checking to make sure these library functions are marked readnone void test_builtins(double d, float f, long double ld) { @@ -85,9 +85,9 @@ void test_builtins(double d, float f, long double ld) { double atan_ = atan(d); long double atanl_ = atanl(ld); float atanf_ = atanf(f); -// CHECK-NO: declare double @llvm.atan.f64(double) [[NUW_RNI:#[0-9]+]] -// CHECK-NO: declare x86_fp80 @llvm.atan.f80(x86_fp80) [[NUW_RNI]] -// CHECK-NO: declare float @llvm.atan.f32(float) [[NUW_RNI]] +// CHECK-NO: declare double @llvm.atan.f64(double) [[NUW_RN2:#[0-9]+]] +// CHECK-NO: declare x86_fp80 @llvm.atan.f80(x86_fp80) [[NUW_RN2]] +// CHECK-NO: declare float @llvm.atan.f32(float) [[NUW_RN2]] // CHECK-YES: declare double @atan(double noundef) [[NUW:#[0-9]+]] // CHECK-YES: declare x86_fp80 @atanl(x86_fp80 noundef) [[NUW]] // CHECK-YES: declare float @atanf(float noundef) [[NUW]] @@ -95,9 +95,9 @@ void test_builtins(double d, float f, long double ld) { double atan2_ = atan2(d, 2); long double atan2l_ = atan2l(ld, ld); float atan2f_ = atan2f(f, f); -// CHECK-NO: declare double @llvm.atan2.f64(double, double) [[NUW_RNI]] -// CHECK-NO: declare x86_fp80 @llvm.atan2.f80(x86_fp80, x86_fp80) [[NUW_RNI]] -// CHECK-NO: declare float @llvm.atan2.f32(float, float) [[NUW_RNI]] +// CHECK-NO: declare double @llvm.atan2.f64(double, double) [[NUW_RN2]] +// CHECK-NO: declare x86_fp80 @llvm.atan2.f80(x86_fp80, x86_fp80) [[NUW_RN2]] +// CHECK-NO: declare float @llvm.atan2.f32(float, float) [[NUW_RN2]] // CHECK-YES: declare double @atan2(double noundef, double noundef) [[NUW]] // CHECK-YES: declare x86_fp80 @atan2l(x86_fp80 noundef, x86_fp80 noundef) [[NUW]] // CHECK-YES: declare float @atan2f(float noundef, float noundef) [[NUW]] @@ -124,4 +124,4 @@ void test_builtins(double d, float f, long double ld) { } // CHECK-YES: attributes [[NUW]] = { nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" "target-features"="+cx8,+x87" } -// CHECK-NO-DAG: attributes [[NUW_RNI]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } +// CHECK-NO-DAG: attributes [[NUW_RNI]] = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } diff --git a/clang/test/CodeGen/math-libcalls.c b/clang/test/CodeGen/math-libcalls.c index ad29782..d4cd6f86 100644 --- a/clang/test/CodeGen/math-libcalls.c +++ b/clang/test/CodeGen/math-libcalls.c @@ -35,27 +35,27 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { copysign(f,f); copysignf(f,f);copysignl(f,f); - // NO__ERRNO: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC]] - // NO__ERRNO: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC]] - // NO__ERRNO: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] - // HAS_ERRNO: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC:#[0-9]+]] - // HAS_ERRNO: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC]] - // HAS_ERRNO: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] - // HAS_MAYTRAP: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC:#[0-9]+]] - // HAS_MAYTRAP: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC]] - // HAS_MAYTRAP: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] + // NO__ERRNO: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC2:#[0-9]+]] + // NO__ERRNO: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC2]] + // NO__ERRNO: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] + // HAS_ERRNO: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC2:#[0-9]+]] + // HAS_ERRNO: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC2]] + // HAS_ERRNO: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] + // HAS_MAYTRAP: declare double @llvm.copysign.f64(double, double) [[READNONE_INTRINSIC2:#[0-9]+]] + // HAS_MAYTRAP: declare float @llvm.copysign.f32(float, float) [[READNONE_INTRINSIC2]] + // HAS_MAYTRAP: declare x86_fp80 @llvm.copysign.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] fabs(f); fabsf(f); fabsl(f); - // NO__ERRNO: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC]] - // NO__ERRNO: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC]] - // NO__ERRNO: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC]] - // HAS_ERRNO: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC]] - // HAS_ERRNO: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC]] - // HAS_ERRNO: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC]] - // HAS_MAYTRAP: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC]] - // HAS_MAYTRAP: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC]] - // HAS_MAYTRAP: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC]] + // NO__ERRNO: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC2]] + // NO__ERRNO: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC2]] + // NO__ERRNO: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC2]] + // HAS_ERRNO: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC2]] + // HAS_ERRNO: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC2]] + // HAS_ERRNO: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC2]] + // HAS_MAYTRAP: declare double @llvm.fabs.f64(double) [[READNONE_INTRINSIC2]] + // HAS_MAYTRAP: declare float @llvm.fabs.f32(float) [[READNONE_INTRINSIC2]] + // HAS_MAYTRAP: declare x86_fp80 @llvm.fabs.f80(x86_fp80) [[READNONE_INTRINSIC2]] frexp(f,i); frexpf(f,i); frexpl(f,i); @@ -86,7 +86,7 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { // NO__ERRNO: declare { double, double } @llvm.modf.f64(double) [[READNONE_INTRINSIC]] // NO__ERRNO: declare { float, float } @llvm.modf.f32(float) [[READNONE_INTRINSIC]] // NO__ERRNO: declare { x86_fp80, x86_fp80 } @llvm.modf.f80(x86_fp80) [[READNONE_INTRINSIC]] - // HAS_ERRNO: declare { double, double } @llvm.modf.f64(double) [[READNONE_INTRINSIC]] + // HAS_ERRNO: declare { double, double } @llvm.modf.f64(double) [[READNONE_INTRINSIC:#[0-9]+]] // HAS_ERRNO: declare { float, float } @llvm.modf.f32(float) [[READNONE_INTRINSIC]] // HAS_ERRNO: declare { x86_fp80, x86_fp80 } @llvm.modf.f80(x86_fp80) [[READNONE_INTRINSIC]] // HAS_MAYTRAP: declare double @modf(double noundef, ptr noundef) [[NOT_READNONE]] @@ -107,9 +107,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { pow(f,f); powf(f,f); powl(f,f); -// NO__ERRNO: declare double @llvm.pow.f64(double, double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.pow.f32(float, float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.pow.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.pow.f64(double, double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.pow.f32(float, float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.pow.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @pow(double noundef, double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @powf(float noundef, float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @powl(x86_fp80 noundef, x86_fp80 noundef) [[NOT_READNONE]] @@ -206,21 +206,21 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { ceil(f); ceilf(f); ceill(f); -// NO__ERRNO: declare double @llvm.ceil.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.ceil.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.ceil.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.ceil.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.ceil.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.ceil.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.ceil.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.ceil.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.ceil.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.ceil.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.ceil.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.ceil.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_MAYTRAP: declare double @llvm.experimental.constrained.ceil.f64( // HAS_MAYTRAP: declare float @llvm.experimental.constrained.ceil.f32( // HAS_MAYTRAP: declare x86_fp80 @llvm.experimental.constrained.ceil.f80( cos(f); cosf(f); cosl(f); -// NO__ERRNO: declare double @llvm.cos.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.cos.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.cos.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.cos.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.cos.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.cos.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @cos(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @cosf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @cosl(x86_fp80 noundef) [[NOT_READNONE]] @@ -266,9 +266,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { exp(f); expf(f); expl(f); -// NO__ERRNO: declare double @llvm.exp.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.exp.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.exp.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.exp.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.exp.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.exp.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @exp(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @expf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @expl(x86_fp80 noundef) [[NOT_READNONE]] @@ -278,9 +278,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { exp2(f); exp2f(f); exp2l(f); -// NO__ERRNO: declare double @llvm.exp2.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.exp2.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.exp2.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.exp2.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.exp2.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.exp2.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @exp2(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @exp2f(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @exp2l(x86_fp80 noundef) [[NOT_READNONE]] @@ -314,21 +314,21 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { floor(f); floorf(f); floorl(f); -// NO__ERRNO: declare double @llvm.floor.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.floor.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.floor.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.floor.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.floor.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.floor.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.floor.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.floor.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.floor.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.floor.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.floor.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.floor.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_MAYTRAP: declare double @llvm.experimental.constrained.floor.f64 // HAS_MAYTRAP: declare float @llvm.experimental.constrained.floor.f32( // HAS_MAYTRAP: declare x86_fp80 @llvm.experimental.constrained.floor.f80( fma(f,f,f); fmaf(f,f,f); fmal(f,f,f); -// NO__ERRNO: declare double @llvm.fma.f64(double, double, double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.fma.f32(float, float, float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.fma.f64(double, double, double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.fma.f32(float, float, float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.fma.f80(x86_fp80, x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @fma(double noundef, double noundef, double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @fmaf(float noundef, float noundef, float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @fmal(x86_fp80 noundef, x86_fp80 noundef, x86_fp80 noundef) [[NOT_READNONE]] @@ -350,39 +350,39 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { fmax(f,f); fmaxf(f,f); fmaxl(f,f); -// NO__ERRNO: declare double @llvm.maxnum.f64(double, double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.maxnum.f32(float, float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.maxnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.maxnum.f64(double, double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.maxnum.f32(float, float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.maxnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.maxnum.f64(double, double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.maxnum.f32(float, float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.maxnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.maxnum.f64(double, double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.maxnum.f32(float, float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.maxnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] // HAS_MAYTRAP: declare double @llvm.experimental.constrained.maxnum.f64( // HAS_MAYTRAP: declare float @llvm.experimental.constrained.maxnum.f32( // HAS_MAYTRAP: declare x86_fp80 @llvm.experimental.constrained.maxnum.f80( fmin(f,f); fminf(f,f); fminl(f,f); -// NO__ERRNO: declare double @llvm.minnum.f64(double, double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.minnum.f64(double, double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.minnum.f64(double, double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.minnum.f64(double, double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.minnum.f32(float, float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.minnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] // HAS_MAYTRAP: declare double @llvm.experimental.constrained.minnum.f64( // HAS_MAYTRAP: declare float @llvm.experimental.constrained.minnum.f32( // HAS_MAYTRAP: declare x86_fp80 @llvm.experimental.constrained.minnum.f80( fmaximum_num(*d,*d); fmaximum_numf(f,f); fmaximum_numl(*l,*l); -// COMMON: declare double @llvm.maximumnum.f64(double, double) [[READNONE_INTRINSIC]] -// COMMON: declare float @llvm.maximumnum.f32(float, float) [[READNONE_INTRINSIC]] -// COMMON: declare x86_fp80 @llvm.maximumnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] +// COMMON: declare double @llvm.maximumnum.f64(double, double) [[READNONE_INTRINSIC2]] +// COMMON: declare float @llvm.maximumnum.f32(float, float) [[READNONE_INTRINSIC2]] +// COMMON: declare x86_fp80 @llvm.maximumnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] fminimum_num(*d,*d); fminimum_numf(f,f); fminimum_numl(*l,*l); -// COMMON: declare double @llvm.minimumnum.f64(double, double) [[READNONE_INTRINSIC]] -// COMMON: declare float @llvm.minimumnum.f32(float, float) [[READNONE_INTRINSIC]] -// COMMON: declare x86_fp80 @llvm.minimumnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC]] +// COMMON: declare double @llvm.minimumnum.f64(double, double) [[READNONE_INTRINSIC2]] +// COMMON: declare float @llvm.minimumnum.f32(float, float) [[READNONE_INTRINSIC2]] +// COMMON: declare x86_fp80 @llvm.minimumnum.f80(x86_fp80, x86_fp80) [[READNONE_INTRINSIC2]] hypot(f,f); hypotf(f,f); hypotl(f,f); @@ -422,9 +422,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { llrint(f); llrintf(f); llrintl(f); -// NO__ERRNO: declare i64 @llvm.llrint.i64.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.llrint.i64.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.llrint.i64.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare i64 @llvm.llrint.i64.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.llrint.i64.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.llrint.i64.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare i64 @llrint(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @llrintf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @llrintl(x86_fp80 noundef) [[NOT_READNONE]] @@ -434,9 +434,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { llround(f); llroundf(f); llroundl(f); -// NO__ERRNO: declare i64 @llvm.llround.i64.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.llround.i64.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.llround.i64.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare i64 @llvm.llround.i64.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.llround.i64.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.llround.i64.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare i64 @llround(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @llroundf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @llroundl(x86_fp80 noundef) [[NOT_READNONE]] @@ -446,9 +446,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { log(f); logf(f); logl(f); -// NO__ERRNO: declare double @llvm.log.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.log.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.log.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.log.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.log.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.log.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @log(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @logf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @logl(x86_fp80 noundef) [[NOT_READNONE]] @@ -458,9 +458,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { log10(f); log10f(f); log10l(f); -// NO__ERRNO: declare double @llvm.log10.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.log10.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.log10.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.log10.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.log10.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.log10.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @log10(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @log10f(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @log10l(x86_fp80 noundef) [[NOT_READNONE]] @@ -482,9 +482,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { log2(f); log2f(f); log2l(f); -// NO__ERRNO: declare double @llvm.log2.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.log2.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.log2.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.log2.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.log2.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.log2.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @log2(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @log2f(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @log2l(x86_fp80 noundef) [[NOT_READNONE]] @@ -506,9 +506,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { lrint(f); lrintf(f); lrintl(f); -// NO__ERRNO: declare i64 @llvm.lrint.i64.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.lrint.i64.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.lrint.i64.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare i64 @llvm.lrint.i64.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.lrint.i64.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.lrint.i64.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare i64 @lrint(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @lrintf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @lrintl(x86_fp80 noundef) [[NOT_READNONE]] @@ -518,9 +518,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { lround(f); lroundf(f); lroundl(f); -// NO__ERRNO: declare i64 @llvm.lround.i64.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.lround.i64.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare i64 @llvm.lround.i64.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare i64 @llvm.lround.i64.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.lround.i64.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare i64 @llvm.lround.i64.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare i64 @lround(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @lroundf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare i64 @lroundl(x86_fp80 noundef) [[NOT_READNONE]] @@ -530,12 +530,12 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { nearbyint(f); nearbyintf(f); nearbyintl(f); -// NO__ERRNO: declare double @llvm.nearbyint.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.nearbyint.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.nearbyint.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.nearbyint.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.nearbyint.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.nearbyint.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.nearbyint.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.nearbyint.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.nearbyint.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.nearbyint.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.nearbyint.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.nearbyint.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_MAYTRAP: declare double @llvm.experimental.constrained.nearbyint.f64( // HAS_MAYTRAP: declare float @llvm.experimental.constrained.nearbyint.f32( // HAS_MAYTRAP: declare x86_fp80 @llvm.experimental.constrained.nearbyint.f80( @@ -590,24 +590,24 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { rint(f); rintf(f); rintl(f); -// NO__ERRNO: declare double @llvm.rint.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.rint.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.rint.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.rint.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.rint.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.rint.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.rint.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.rint.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.rint.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.rint.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.rint.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.rint.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_MAYTRAP: declare double @llvm.experimental.constrained.rint.f64( // HAS_MAYTRAP: declare float @llvm.experimental.constrained.rint.f32( // HAS_MAYTRAP: declare x86_fp80 @llvm.experimental.constrained.rint.f80( round(f); roundf(f); roundl(f); -// NO__ERRNO: declare double @llvm.round.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.round.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.round.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.round.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.round.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.round.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.round.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.round.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.round.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.round.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.round.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.round.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_MAYTRAP: declare double @llvm.experimental.constrained.round.f64( // HAS_MAYTRAP: declare float @llvm.experimental.constrained.round.f32( // HAS_MAYTRAP: declare x86_fp80 @llvm.experimental.constrained.round.f80( @@ -638,9 +638,9 @@ void foo(double *d, float f, float *fp, long double *l, int *i, const char *c) { sin(f); sinf(f); sinl(f); -// NO__ERRNO: declare double @llvm.sin.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.sin.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.sin.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.sin.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.sin.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.sin.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @sin(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @sinf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @sinl(x86_fp80 noundef) [[NOT_READNONE]] @@ -674,9 +674,9 @@ sincos(f, d, d); sincosf(f, fp, fp); sincosl(f, l, l); sqrt(f); sqrtf(f); sqrtl(f); -// NO__ERRNO: declare double @llvm.sqrt.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.sqrt.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.sqrt.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.sqrt.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.sqrt.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.sqrt.f80(x86_fp80) [[READNONE_INTRINSIC2]] // HAS_ERRNO: declare double @sqrt(double noundef) [[NOT_READNONE]] // HAS_ERRNO: declare float @sqrtf(float noundef) [[NOT_READNONE]] // HAS_ERRNO: declare x86_fp80 @sqrtl(x86_fp80 noundef) [[NOT_READNONE]] @@ -722,20 +722,22 @@ sincos(f, d, d); sincosf(f, fp, fp); sincosl(f, l, l); trunc(f); truncf(f); truncl(f); -// NO__ERRNO: declare double @llvm.trunc.f64(double) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare float @llvm.trunc.f32(float) [[READNONE_INTRINSIC]] -// NO__ERRNO: declare x86_fp80 @llvm.trunc.f80(x86_fp80) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare double @llvm.trunc.f64(double) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare float @llvm.trunc.f32(float) [[READNONE_INTRINSIC]] -// HAS_ERRNO: declare x86_fp80 @llvm.trunc.f80(x86_fp80) [[READNONE_INTRINSIC]] +// NO__ERRNO: declare double @llvm.trunc.f64(double) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare float @llvm.trunc.f32(float) [[READNONE_INTRINSIC2]] +// NO__ERRNO: declare x86_fp80 @llvm.trunc.f80(x86_fp80) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare double @llvm.trunc.f64(double) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare float @llvm.trunc.f32(float) [[READNONE_INTRINSIC2]] +// HAS_ERRNO: declare x86_fp80 @llvm.trunc.f80(x86_fp80) [[READNONE_INTRINSIC2]] }; // NO__ERRNO: attributes [[READNONE_INTRINSIC]] = { {{.*}}memory(none){{.*}} } +// NO__ERRNO: attributes [[READNONE_INTRINSIC2]] = { {{.*}}memory(none){{.*}} } // NO__ERRNO: attributes [[NOT_READNONE]] = { nounwind {{.*}} } // NO__ERRNO: attributes [[READNONE]] = { {{.*}}memory(none){{.*}} } // NO__ERRNO: attributes [[READONLY]] = { {{.*}}memory(read){{.*}} } // HAS_ERRNO: attributes [[NOT_READNONE]] = { nounwind {{.*}} } +// HAS_ERRNO: attributes [[READNONE_INTRINSIC2]] = { {{.*}}memory(none){{.*}} } // HAS_ERRNO: attributes [[READNONE_INTRINSIC]] = { {{.*}}memory(none){{.*}} } // HAS_ERRNO: attributes [[READONLY]] = { {{.*}}memory(read){{.*}} } // HAS_ERRNO: attributes [[READNONE]] = { {{.*}}memory(none){{.*}} } diff --git a/clang/test/CodeGenOpenCL/cl20-device-side-enqueue-attributes.cl b/clang/test/CodeGenOpenCL/cl20-device-side-enqueue-attributes.cl index ea1f734..5cbf645 100644 --- a/clang/test/CodeGenOpenCL/cl20-device-side-enqueue-attributes.cl +++ b/clang/test/CodeGenOpenCL/cl20-device-side-enqueue-attributes.cl @@ -199,7 +199,7 @@ kernel void device_side_enqueue(global float *a, global float *b, int i) { // SPIR32: attributes #[[ATTR0]] = { convergent noinline norecurse nounwind optnone "denormal-fp-math-f32"="preserve-sign,preserve-sign" "no-trapping-math"="true" "stack-protector-buffer-size"="8" "uniform-work-group-size"="true" } // SPIR32: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) } // SPIR32: attributes #[[ATTR2]] = { convergent noinline nounwind optnone "denormal-fp-math-f32"="preserve-sign,preserve-sign" "no-trapping-math"="true" "stack-protector-buffer-size"="8" } -// SPIR32: attributes #[[ATTR3:[0-9]+]] = { nocallback nofree nosync nounwind speculatable willreturn memory(none) } +// SPIR32: attributes #[[ATTR3:[0-9]+]] = { nocallback nocreateundeforpoison nofree nosync nounwind speculatable willreturn memory(none) } // SPIR32: attributes #[[ATTR4]] = { convergent nounwind "denormal-fp-math-f32"="preserve-sign,preserve-sign" "no-trapping-math"="true" "stack-protector-buffer-size"="8" } // SPIR32: attributes #[[ATTR5]] = { convergent nounwind "uniform-work-group-size"="true" } //. diff --git a/clang/test/DebugInfo/KeyInstructions/flag.cpp b/clang/test/DebugInfo/KeyInstructions/flag.cpp index 6aeeed6..4a4a5c4 100644 --- a/clang/test/DebugInfo/KeyInstructions/flag.cpp +++ b/clang/test/DebugInfo/KeyInstructions/flag.cpp @@ -8,6 +8,9 @@ // KEY-INSTRUCTIONS: "-gkey-instructions" // NO-KEY-INSTRUCTIONS-NOT: key-instructions + +// Only expect one dwarf related flag. +// NO-DEBUG: -fdwarf2-cfi-asm // NO-DEBUG-NOT: debug-info-kind // NO-DEBUG-NOT: dwarf diff --git a/clang/test/Frontend/diags-interesting-source-region-colors.cpp b/clang/test/Frontend/diags-interesting-source-region-colors.cpp new file mode 100644 index 0000000..80db087 --- /dev/null +++ b/clang/test/Frontend/diags-interesting-source-region-colors.cpp @@ -0,0 +1,30 @@ +// RUN: not %clang_cc1 %s -fmessage-length=40 -fcolor-diagnostics -fno-show-source-location -Wunused-value -o - 2>&1 | FileCheck %s + +// REQUIRES: ansi-escape-sequences + +int main() { + 1 + + if; + // CHECK: expected expression + // CHECK-NEXT: ...+ [[MAGENTA:.\[0;34m]]if[[RESET:.\[0m]]; + + /*😂*/1 + + if; + // CHECK: expected expression + // CHECK-NEXT: ...+ [[MAGENTA:.\[0;34m]]if[[RESET:.\[0m]]; + + a + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1; + // CHECK: use of undeclared identifier + // CHECK-NEXT: a + [[GREEN:.\[0;32m]]1[[RESET]] + [[GREEN]]1[[RESET]] + [[GREEN]]1[[RESET]] + [[GREEN]]1[[RESET]] + [[GREEN]]1[[RESET]] ... + + + /*😂😂😂*/ a + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1; + // CHECK: use of undeclared identifier + // CHECK-NEXT: [[YELLOW:.\[0;33m]]/*😂😂😂*/[[RESET]] a + [[GREEN:.\[0;32m]]1[[RESET]] + [[GREEN]]1[[RESET]] ... + + "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; + // CHECK: [[GREEN:.\[0;32m]]"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"[[RESET]]; + + "😂xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"; + // CHECK: [[GREEN:.\[0;32m]]"😂xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"[[RESET]]; +} + + diff --git a/clang/test/Modules/Inputs/builtin-headers/system-modules.modulemap b/clang/test/Modules/Inputs/builtin-headers/system-modules.modulemap index 1869651..8ab6ae47 100644 --- a/clang/test/Modules/Inputs/builtin-headers/system-modules.modulemap +++ b/clang/test/Modules/Inputs/builtin-headers/system-modules.modulemap @@ -49,6 +49,11 @@ module cstd [system] [no_undeclared_includes] { export * } + module stdckdint { + header "stdckdint.h" + export * + } + module stdcountof { header "stdcountof.h" export * diff --git a/clang/test/Modules/builtin-headers.mm b/clang/test/Modules/builtin-headers.mm index ad2d66a..6cd3662 100644 --- a/clang/test/Modules/builtin-headers.mm +++ b/clang/test/Modules/builtin-headers.mm @@ -17,6 +17,7 @@ @import _Builtin_stdarg; @import _Builtin_stdatomic; @import _Builtin_stdbool; +@import _Builtin_stdckdint; @import _Builtin_stdcountof; @import _Builtin_stddef; @import _Builtin_stdint; diff --git a/clang/test/Modules/crash-enum-visibility-with-header-unit.cppm b/clang/test/Modules/crash-enum-visibility-with-header-unit.cppm new file mode 100644 index 0000000..90c5779 --- /dev/null +++ b/clang/test/Modules/crash-enum-visibility-with-header-unit.cppm @@ -0,0 +1,46 @@ +// Fixes #165445 + +// RUN: rm -rf %t +// RUN: mkdir -p %t +// RUN: split-file %s %t +// +// RUN: %clang_cc1 -std=c++20 -x c++-user-header %t/header.h \ +// RUN: -emit-header-unit -o %t/header.pcm +// +// RUN: %clang_cc1 -std=c++20 %t/A.cppm -fmodule-file=%t/header.pcm \ +// RUN: -emit-module-interface -o %t/A.pcm +// +// RUN: %clang_cc1 -std=c++20 %t/B.cppm -fmodule-file=%t/header.pcm \ +// RUN: -emit-module-interface -o %t/B.pcm +// +// RUN: %clang_cc1 -std=c++20 %t/use.cpp \ +// RUN: -fmodule-file=A=%t/A.pcm -fmodule-file=B=%t/B.pcm \ +// RUN: -fmodule-file=%t/header.pcm \ +// RUN: -verify -fsyntax-only + +//--- enum.h +enum E { Value }; + +//--- header.h +#include "enum.h" + +//--- A.cppm +module; +#include "enum.h" +export module A; + +auto e = Value; + +//--- B.cppm +export module B; +import "header.h"; + +auto e = Value; + +//--- use.cpp +// expected-no-diagnostics +import A; +import B; +#include "enum.h" + +auto e = Value; diff --git a/clang/test/Preprocessor/unwind-tables.c b/clang/test/Preprocessor/unwind-tables.c index 0a863d7..5ff990d 100644 --- a/clang/test/Preprocessor/unwind-tables.c +++ b/clang/test/Preprocessor/unwind-tables.c @@ -1,11 +1,13 @@ // RUN: %clang %s -dM -E -target x86_64-windows | FileCheck %s --check-prefix=NO // RUN: %clang %s -dM -E -target x86_64 -fno-asynchronous-unwind-tables | FileCheck %s --check-prefix=NO +// RUN: %clang %s -dM -E -target x86_64 -fno-dwarf2-cfi-asm | FileCheck %s --check-prefix=NO // RUN: %clang %s -dM -E -target x86_64 | FileCheck %s // RUN: %clang %s -dM -E -target x86_64 -funwind-tables -fno-asynchronous-unwind-tables -g | FileCheck %s // RUN: %clang %s -dM -E -target aarch64-apple-darwin | FileCheck %s // RUN: %clang %s -dM -E -target x86_64 -fno-asynchronous-unwind-tables -g | FileCheck %s // RUN: %clang %s -dM -E -target x86_64 -fno-asynchronous-unwind-tables -fexceptions | FileCheck %s +// RUN: %clang %s -dM -E -target x86_64-windows -fdwarf2-cfi-asm | FileCheck %s // NO-NOT: #define __GCC_HAVE_DWARF2_CFI_ASM // CHECK: #define __GCC_HAVE_DWARF2_CFI_ASM 1 diff --git a/clang/test/Sema/attr-nonblocking-constraints.cpp b/clang/test/Sema/attr-nonblocking-constraints.cpp index b26a945..881e816 100644 --- a/clang/test/Sema/attr-nonblocking-constraints.cpp +++ b/clang/test/Sema/attr-nonblocking-constraints.cpp @@ -235,16 +235,35 @@ void nb13() [[clang::nonblocking]] { nb12(); } // C++ member function pointers struct PTMFTester { typedef void (PTMFTester::*ConvertFunction)() [[clang::nonblocking]]; - - void convert() [[clang::nonblocking]]; + typedef void (PTMFTester::*BlockingFunction)(); ConvertFunction mConvertFunc; -}; -void PTMFTester::convert() [[clang::nonblocking]] -{ - (this->*mConvertFunc)(); -} + void convert() [[clang::nonblocking]] + { + (this->*mConvertFunc)(); // This should not generate a warning. + } + + template <typename T> + struct Holder { + T value; + + T& operator*() { return value; } + }; + + + void ptmfInExpr(Holder<ConvertFunction>& holder) [[clang::nonblocking]] + { + (this->*(*holder))(); // Should not generate a warning. + ((*this).*(*holder))(); // Should not generate a warning. + } + + void ptmfInExpr(Holder<BlockingFunction>& holder) [[clang::nonblocking]] + { + (this->*(*holder))(); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' expression}} + ((*this).*(*holder))(); // expected-warning {{function with 'nonblocking' attribute must not call non-'nonblocking' expression}} + } +}; // Allow implicit conversion from array to pointer. void nb14(unsigned idx) [[clang::nonblocking]] @@ -354,6 +373,33 @@ struct Unsafe { Unsafe(float y) [[clang::nonblocking]] : Unsafe(int(y)) {} // expected-warning {{constructor with 'nonblocking' attribute must not call non-'nonblocking' constructor 'Unsafe::Unsafe'}} }; +// Exercise cases of a temporary with a safe constructor and unsafe destructor. +void nb23() +{ + struct X { + int *ptr = nullptr; + X() {} + ~X() { delete ptr; } // expected-note 2 {{destructor cannot be inferred 'nonblocking' because it allocates or deallocates memory}} + }; + + auto inner = []() [[clang::nonblocking]] { + X(); // expected-warning {{lambda with 'nonblocking' attribute must not call non-'nonblocking' destructor 'nb23()::X::~X'}} + }; + + auto inner2 = [](X x) [[clang::nonblocking]] { // expected-warning {{lambda with 'nonblocking' attribute must not call non-'nonblocking' destructor 'nb23()::X::~X'}} + }; + +} + +struct S2 { ~S2(); }; // expected-note 2 {{declaration cannot be inferred 'nonblocking' because it has no definition in this translation unit}} +void nb24() { + S2 s; + [&]() [[clang::nonblocking]] { + [s]{ auto x = &s; }(); // expected-warning {{lambda with 'nonblocking' attribute must not call non-'nonblocking' destructor}} expected-note {{destructor cannot be inferred 'nonblocking' because it calls non-'nonblocking' destructor 'S2::~S2'}} + [=]{ auto x = &s; }(); // expected-warning {{lambda with 'nonblocking' attribute must not call non-'nonblocking' destructor}} expected-note {{destructor cannot be inferred 'nonblocking' because it calls non-'nonblocking' destructor 'S2::~S2'}} + }(); +} + struct DerivedFromUnsafe : public Unsafe { DerivedFromUnsafe() [[clang::nonblocking]] {} // expected-warning {{constructor with 'nonblocking' attribute must not call non-'nonblocking' constructor 'Unsafe::Unsafe'}} DerivedFromUnsafe(int x) [[clang::nonblocking]] : Unsafe(x) {} // expected-warning {{constructor with 'nonblocking' attribute must not call non-'nonblocking' constructor 'Unsafe::Unsafe'}} diff --git a/clang/test/Sema/labeled-break-continue.c b/clang/test/Sema/labeled-break-continue.c index 78f81c4..6b4adc2 100644 --- a/clang/test/Sema/labeled-break-continue.c +++ b/clang/test/Sema/labeled-break-continue.c @@ -1,6 +1,6 @@ -// RUN: %clang_cc1 -std=c2y -verify -fsyntax-only -fblocks %s -// RUN: %clang_cc1 -std=c23 -verify -fsyntax-only -fblocks -fnamed-loops %s -// RUN: %clang_cc1 -x c++ -verify -fsyntax-only -fblocks -fnamed-loops %s +// RUN: %clang_cc1 -std=c2y -verify -Wunused -fsyntax-only -fblocks %s +// RUN: %clang_cc1 -std=c23 -verify -Wunused -fsyntax-only -fblocks -fnamed-loops %s +// RUN: %clang_cc1 -x c++ -verify -Wunused -fsyntax-only -fblocks -fnamed-loops %s void f1() { l1: while (true) { @@ -159,3 +159,15 @@ void f7() { continue d; // expected-error {{'continue' label does not name an enclosing loop}} } } + +void f8() { + l1: // no-warning + while (true) { + break l1; + } + + l2: // no-warning + while (true) { + continue l2; + } +} diff --git a/clang/test/SemaCXX/vector.cpp b/clang/test/SemaCXX/vector.cpp index 808bdb6..06195f0 100644 --- a/clang/test/SemaCXX/vector.cpp +++ b/clang/test/SemaCXX/vector.cpp @@ -786,3 +786,16 @@ const long long e = *0; // expected-error {{indirection requires pointer operand double f = a - e; // expected-error {{cannot initialize a variable of type 'double' with an rvalue of type '__attribute__((__vector_size__(1 * sizeof(double)))) double' (vector of 1 'double' value)}} int h = c - e; // expected-error {{cannot initialize a variable of type 'int' with an rvalue of type '__attribute__((__vector_size__(1 * sizeof(long)))) long' (vector of 1 'long' value)}} } + +typedef int v_neg_size __attribute__((vector_size(-8))); // expected-error{{vector must have non-negative size}} +typedef int v_neg_size_2 __attribute__((vector_size(-1 * 8))); // expected-error{{vector must have non-negative size}} +typedef int v_ext_neg_size __attribute__((ext_vector_type(-8))); // expected-error{{vector must have non-negative size}} +typedef int v_ext_neg_size2 __attribute__((ext_vector_type(-1 * 8))); // expected-error{{vector must have non-negative size}} + + +#if __cplusplus >= 201103L + +template <int N> using templated_v_size = int __attribute__((vector_size(N))); // expected-error{{vector must have non-negative size}} +templated_v_size<-8> templated_v_neg_size; //expected-note{{in instantiation of template type alias 'templated_v_size' requested here}} + +#endif diff --git a/clang/test/SemaTemplate/ctad.cpp b/clang/test/SemaTemplate/ctad.cpp index 1a575ea..60603f0 100644 --- a/clang/test/SemaTemplate/ctad.cpp +++ b/clang/test/SemaTemplate/ctad.cpp @@ -104,3 +104,15 @@ namespace ConvertDeducedTemplateArgument { auto x = C(D<A::B>()); } + +namespace pr165560 { +template <class T, class> struct S { + using A = T; + template <class> struct I { // expected-note{{candidate function template not viable: requires 1 argument, but 0 were provided}} \ + // expected-note{{implicit deduction guide declared as 'template <class> I(pr165560::S<int, int>::I<type-parameter-0-0>) -> pr165560::S<int, int>::I<type-parameter-0-0>'}} + I(typename A::F) {} // expected-error{{type 'A' (aka 'int') cannot be used prior to '::' because it has no members}} + }; +}; +S<int, int>::I i; // expected-error{{no viable constructor or deduction guide for deduction of template arguments of 'S<int, int>::I'}} \ + // expected-note{{while building implicit deduction guide first needed here}} +} diff --git a/clang/tools/scan-build/bin/set-xcode-analyzer b/clang/tools/scan-build/bin/set-xcode-analyzer index 8e4a579..5d98c0c 100755 --- a/clang/tools/scan-build/bin/set-xcode-analyzer +++ b/clang/tools/scan-build/bin/set-xcode-analyzer @@ -5,10 +5,6 @@ # This one has the scripting bridge enabled. import sys -if sys.version_info < (3, 6): - print "set-xcode-analyzer requires Python 3.6 or later" - sys.exit(1) - import os import subprocess import re @@ -18,7 +14,7 @@ import stat from AppKit import * def FindClangSpecs(path): - print "(+) Searching for xcspec file in: ", path + print("(+) Searching for xcspec file in: ", path) for root, dirs, files in os.walk(path): for f in files: if f.endswith(".xcspec") and f.startswith("Clang LLVM"): @@ -49,14 +45,14 @@ def ModifySpec(path, isBuiltinAnalyzer, pathToChecker): foundAnalyzer = False t.write(line) t.close() - print "(+) processing:", path + print("(+) processing:", path) try: shutil.copy(t.name, path) os.chmod(path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH) - except IOError, why: - print " (-) Cannot update file:", why, "\n" - except OSError, why: - print " (-) Cannot update file:", why, "\n" + except IOError as why: + print(" (-) Cannot update file:", why, "\n") + except OSError as why: + print(" (-) Cannot update file:", why, "\n") os.unlink(t.name) def main(): @@ -75,7 +71,7 @@ def main(): # determine if Xcode is running for x in NSWorkspace.sharedWorkspace().runningApplications(): if x.localizedName().find("Xcode") >= 0: - print "(-) You must quit Xcode first before modifying its configuration files." + print("(-) You must quit Xcode first before modifying its configuration files.") sys.exit(1) isBuiltinAnalyzer = False @@ -83,12 +79,12 @@ def main(): # Expand tildes. path = os.path.expanduser(options.path) if not path.endswith("clang"): - print "(+) Using Clang bundled with checker build:", path + print("(+) Using Clang bundled with checker build:", path) path = os.path.join(path, "bin", "clang"); else: - print "(+) Using Clang located at:", path + print("(+) Using Clang located at:", path) else: - print "(+) Using the Clang bundled with Xcode" + print("(+) Using the Clang bundled with Xcode") path = options.default isBuiltinAnalyzer = True @@ -108,7 +104,7 @@ def main(): ModifySpec(x, isBuiltinAnalyzer, path) if not foundSpec: - print "(-) No compiler configuration file was found. Xcode's analyzer has not been updated." + print("(-) No compiler configuration file was found. Xcode's analyzer has not been updated.") if __name__ == '__main__': main() diff --git a/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp b/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp index ef22960..8fc9a66d 100644 --- a/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp +++ b/clang/unittests/Analysis/ExprMutationAnalyzerTest.cpp @@ -2076,4 +2076,19 @@ TEST(ExprMutationAnalyzerTest, PointeeMutatedByReturn) { } } +TEST(ExprMutationAnalyzerTest, PointeeMutatedByPointerToMemberOperator) { + // GH161913 + const std::string Code = R"( + struct S { int i; }; + void f(S s) { + S *x = &s; + (x->*(&S::i))++; + } + )"; + auto AST = buildASTFromCodeWithArgs(Code, {"-Wno-everything"}); + auto Results = + match(withEnclosingCompound(declRefTo("x")), AST->getASTContext()); + EXPECT_TRUE(isPointeeMutated(Results, AST.get())); +} + } // namespace clang diff --git a/clang/unittests/Format/FormatTest.cpp b/clang/unittests/Format/FormatTest.cpp index ca9e792..24235b9 100644 --- a/clang/unittests/Format/FormatTest.cpp +++ b/clang/unittests/Format/FormatTest.cpp @@ -20824,6 +20824,13 @@ TEST_F(FormatTest, AlignWithLineBreaks) { " argument1,\n" " argument2);", Style); + + Style.ColumnLimit = 45; + verifyFormat("auto xxxxxxxx = foo;\n" + "auto x = whatever ? some / long -\n" + " computition / stuff\n" + " : random;", + Style); } TEST_F(FormatTest, AlignWithInitializerPeriods) { diff --git a/clang/unittests/Format/FormatTestComments.cpp b/clang/unittests/Format/FormatTestComments.cpp index 399f835..d7b2257 100644 --- a/clang/unittests/Format/FormatTestComments.cpp +++ b/clang/unittests/Format/FormatTestComments.cpp @@ -106,24 +106,12 @@ TEST_F(FormatTestComments, UnderstandsSingleLineComments) { " // line c\n" " c\n" "};", - "enum A {\n" - " // line a\n" - " a,\n" - " b, // line b\n" - "\n" - " // line c\n" - " c\n" - "};", - Style20); - verifyFormat("enum A {\n" - " a, // line 1\n" - " // line 2\n" - "};", - "enum A {\n" - " a, // line 1\n" - " // line 2\n" - "};", Style20); + verifyNoChange("enum A {\n" + " a, // line 1\n" + " // line 2\n" + "};", + Style20); verifyFormat("enum A {\n" " a, // line 1\n" " // line 2\n" @@ -133,17 +121,12 @@ TEST_F(FormatTestComments, UnderstandsSingleLineComments) { " // line 2\n" "};", Style20); - verifyFormat("enum A {\n" - " a, // line 1\n" - " // line 2\n" - " b\n" - "};", - "enum A {\n" - " a, // line 1\n" - " // line 2\n" - " b\n" - "};", - Style20); + verifyNoChange("enum A {\n" + " a, // line 1\n" + " // line 2\n" + " b\n" + "};", + Style20); verifyFormat("enum A {\n" " a, // line 1\n" " // line 2\n" @@ -487,12 +470,9 @@ TEST_F(FormatTestComments, AlignsBlockComments) { " Don't try to outdent if there's not enough indentation.\n" " */"); - verifyFormat("int i; /* Comment with empty...\n" - " *\n" - " * line. */", - "int i; /* Comment with empty...\n" - " *\n" - " * line. */"); + verifyNoChange("int i; /* Comment with empty...\n" + " *\n" + " * line. */"); verifyFormat("int foobar = 0; /* comment */\n" "int bar = 0; /* multiline\n" " comment 1 */\n" @@ -555,8 +535,6 @@ TEST_F(FormatTestComments, CommentReflowingCanApplyOnlyToIndents) { TEST_F(FormatTestComments, CorrectlyHandlesLengthOfBlockComments) { verifyFormat("double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" - " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */", - "double *x; /* aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n" " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa */"); verifyFormat( "void ffffffffffff(\n" @@ -680,17 +658,12 @@ TEST_F(FormatTestComments, SplitsLongCxxComments) { verifyFormat("#define XXX // q w e r\n" " // t y u i", "#define XXX //q w e r t y u i", Style22); - verifyFormat("{\n" - " //\n" - " //\\\n" - " // long 1 2 3 4 5\n" - "}", - "{\n" - " //\n" - " //\\\n" - " // long 1 2 3 4 5\n" - "}", - Style20); + verifyNoChange("{\n" + " //\n" + " //\\\n" + " // long 1 2 3 4 5\n" + "}", + Style20); verifyFormat("{\n" " //\n" " //\\\n" @@ -730,19 +703,13 @@ TEST_F(FormatTestComments, PreservesHangingIndentInCxxComments) { } TEST_F(FormatTestComments, DontSplitLineCommentsWithEscapedNewlines) { - verifyFormat("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" - "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" - "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", - "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" - "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" - "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); - verifyFormat("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" - " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" - " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", - "int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" - " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" - " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", - getLLVMStyleWithColumns(50)); + verifyNoChange("// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" + "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n" + "// aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); + verifyNoChange("int a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" + " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" + " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", + getLLVMStyleWithColumns(50)); verifyFormat("double\n" " a; // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" " // AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\\\n" @@ -773,10 +740,8 @@ TEST_F(FormatTestComments, DontIntroduceMultilineComments) { TEST_F(FormatTestComments, DontSplitLineCommentsWithPragmas) { FormatStyle Pragmas = getLLVMStyleWithColumns(30); Pragmas.CommentPragmas = "^ IWYU pragma:"; - verifyFormat("// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", - "// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", Pragmas); - verifyFormat("/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", - "/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", Pragmas); + verifyFormat("// IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb", Pragmas); + verifyFormat("/* IWYU pragma: aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb */", Pragmas); } TEST_F(FormatTestComments, PriorityOfCommentBreaking) { @@ -812,26 +777,17 @@ TEST_F(FormatTestComments, PriorityOfCommentBreaking) { TEST_F(FormatTestComments, MultiLineCommentsInDefines) { const auto Style17 = getLLVMStyleWithColumns(17); - verifyFormat("#define A(x) /* \\\n" - " a comment \\\n" - " inside */ \\\n" - " f();", - "#define A(x) /* \\\n" - " a comment \\\n" - " inside */ \\\n" - " f();", - Style17); - verifyFormat("#define A( \\\n" - " x) /* \\\n" - " a comment \\\n" - " inside */ \\\n" - " f();", - "#define A( \\\n" - " x) /* \\\n" - " a comment \\\n" - " inside */ \\\n" - " f();", - Style17); + verifyNoChange("#define A(x) /* \\\n" + " a comment \\\n" + " inside */ \\\n" + " f();", + Style17); + verifyNoChange("#define A( \\\n" + " x) /* \\\n" + " a comment \\\n" + " inside */ \\\n" + " f();", + Style17); } TEST_F(FormatTestComments, LineCommentsInMacrosDoNotGetEscapedNewlines) { @@ -865,33 +821,20 @@ TEST_F(FormatTestComments, ParsesCommentsAdjacentToPPDirectives) { TEST_F(FormatTestComments, KeepsLevelOfCommentBeforePPDirective) { // Keep the current level if the comment was originally not aligned with // the preprocessor directive. - verifyFormat("void f() {\n" - " int i;\n" - " /* comment */\n" - "#ifdef A\n" - " int j;\n" - "}", - "void f() {\n" - " int i;\n" - " /* comment */\n" - "#ifdef A\n" - " int j;\n" - "}"); + verifyNoChange("void f() {\n" + " int i;\n" + " /* comment */\n" + "#ifdef A\n" + " int j;\n" + "}"); - verifyFormat("void f() {\n" - " int i;\n" - " /* comment */\n" - "\n" - "#ifdef A\n" - " int j;\n" - "}", - "void f() {\n" - " int i;\n" - " /* comment */\n" - "\n" - "#ifdef A\n" - " int j;\n" - "}"); + verifyNoChange("void f() {\n" + " int i;\n" + " /* comment */\n" + "\n" + "#ifdef A\n" + " int j;\n" + "}"); verifyFormat("int f(int i) {\n" " if (true) {\n" @@ -1060,18 +1003,12 @@ TEST_F(FormatTestComments, KeepsLevelOfCommentBeforePPDirective) { // Align with the preprocessor directive if the comment was originally aligned // with the preprocessor directive and there is no newline between the comment // and the preprocessor directive. - verifyFormat("void f() {\n" - " int i;\n" - "/* comment */\n" - "#ifdef A\n" - " int j;\n" - "}", - "void f() {\n" - " int i;\n" - "/* comment */\n" - "#ifdef A\n" - " int j;\n" - "}"); + verifyNoChange("void f() {\n" + " int i;\n" + "/* comment */\n" + "#ifdef A\n" + " int j;\n" + "}"); verifyFormat("int f(int i) {\n" " if (true) {\n" @@ -1245,13 +1182,10 @@ TEST_F(FormatTestComments, SplitsLongLinesInComments) { " wherever_a_space_occurs \n" " */", Style20); - verifyFormat("/*\n" - " * This_comment_can_not_be_broken_into_lines\n" - " */", - "/*\n" - " * This_comment_can_not_be_broken_into_lines\n" - " */", - Style20); + verifyNoChange("/*\n" + " * This_comment_can_not_be_broken_into_lines\n" + " */", + Style20); verifyFormat("{\n" " /*\n" " This is another\n" @@ -1445,17 +1379,12 @@ TEST_F(FormatTestComments, AlignsPPElseEndifComments) { "int iiii; // CC\n" "#endif // B", Style20); - verifyFormat("#if A\n" - "#else // A1\n" - " // A2\n" - "int ii;\n" - "#endif // B", - "#if A\n" - "#else // A1\n" - " // A2\n" - "int ii;\n" - "#endif // B", - Style20); + verifyNoChange("#if A\n" + "#else // A1\n" + " // A2\n" + "int ii;\n" + "#endif // B", + Style20); } TEST_F(FormatTestComments, CommentsInStaticInitializers) { @@ -1528,10 +1457,6 @@ TEST_F(FormatTestComments, LineCommentsAfterRightBrace) { verifyFormat("if (true) { // comment about branch\n" " // comment about f\n" " f();\n" - "}", - "if (true) { // comment about branch\n" - " // comment about f\n" - " f();\n" "}"); verifyFormat("if (1) { // if line 1\n" " // if line 2\n" @@ -1582,6 +1507,7 @@ TEST_F(FormatTestComments, LineCommentsAfterRightBrace) { TEST_F(FormatTestComments, ReflowsComments) { const auto Style20 = getLLVMStyleWithColumns(20); const auto Style22 = getLLVMStyleWithColumns(22); + // Break a long line and reflow with the full next line. verifyFormat("// long long long\n" "// long long", @@ -2149,11 +2075,9 @@ TEST_F(FormatTestComments, ReflowsComments) { Style20); // Don't break or reflow comments on import lines. - verifyFormat("#include \"t\" /* l l l\n" - " * l */", - "#include \"t\" /* l l l\n" - " * l */", - Style20); + verifyNoChange("#include \"t\" /* l l l\n" + " * l */", + Style20); // Don't reflow between different trailing comment sections. verifyFormat("int i; // long long\n" @@ -2209,7 +2133,9 @@ TEST_F(FormatTestComments, ReflowsCommentsPrecise) { "// some text that reflows\n" "// into foo", Style); + Style.ColumnLimit = 21; + // Given one more column, "// reflows into foo" does fit the limit, so we // do not compress the whitespace. verifyFormat("// some text that\n" @@ -2228,6 +2154,7 @@ TEST_F(FormatTestComments, ReflowsCommentsPrecise) { "// some text that reflows\n" "// into1234567", Style); + // Secondly, when the next line ends later, but the first word in that line // is precisely one column over the limit, do not reflow. verifyFormat("// some text that\n" @@ -2240,6 +2167,7 @@ TEST_F(FormatTestComments, ReflowsCommentsPrecise) { TEST_F(FormatTestComments, ReflowsCommentsWithExtraWhitespace) { const auto Style16 = getLLVMStyleWithColumns(16); + // Baseline. verifyFormat("// some text\n" "// that re flows", @@ -2546,37 +2474,23 @@ TEST_F(FormatTestComments, BlockComments) { verifyFormat("void f(int * /* unused */) {}"); - verifyFormat("/*\n" - " **\n" - " */", - "/*\n" - " **\n" - " */"); - verifyFormat("/*\n" - " *q\n" - " */", - "/*\n" - " *q\n" - " */"); - verifyFormat("/*\n" - " * q\n" - " */", - "/*\n" - " * q\n" - " */"); - verifyFormat("/*\n" - " **/", - "/*\n" - " **/"); - verifyFormat("/*\n" - " ***/", - "/*\n" - " ***/"); + verifyNoChange("/*\n" + " **\n" + " */"); + verifyNoChange("/*\n" + " *q\n" + " */"); + verifyNoChange("/*\n" + " * q\n" + " */"); + verifyNoChange("/*\n" + " **/"); + verifyNoChange("/*\n" + " ***/"); } TEST_F(FormatTestComments, BlockCommentsInMacros) { const auto Style20 = getLLVMStyleWithColumns(20); - verifyFormat("#define A \\\n" " { \\\n" " /* one line */ \\\n" @@ -2599,7 +2513,6 @@ TEST_F(FormatTestComments, BlockCommentsInMacros) { TEST_F(FormatTestComments, BlockCommentsAtEndOfLine) { const auto Style15 = getLLVMStyleWithColumns(15); - verifyFormat("a = {\n" " 1111 /* */\n" "};", @@ -2774,11 +2687,6 @@ TEST_F(FormatTestComments, AlignTrailingComments) { " // comment about a\n" " int a;\n" "};", - "class A {\n" - "public: // public comment\n" - " // comment about a\n" - " int a;\n" - "};", Style40); verifyFormat("class A {\n" "public: // public comment 1\n" @@ -3106,41 +3014,26 @@ TEST_F(FormatTestComments, AlignTrailingCommentsLeave) { FormatStyle Style = getLLVMStyle(); Style.AlignTrailingComments.Kind = FormatStyle::TCAS_Leave; - verifyFormat("int a;// do not touch\n" - "int b; // any comments\n" - "int c; // comment\n" - "int d; // comment", - "int a;// do not touch\n" - "int b; // any comments\n" - "int c; // comment\n" - "int d; // comment", - Style); + verifyNoChange("int a;// do not touch\n" + "int b; // any comments\n" + "int c; // comment\n" + "int d; // comment", + Style); - verifyFormat("int a; // do not touch\n" - "int b; // any comments\n" - "int c; // comment\n" - "int d;// comment", - "int a; // do not touch\n" - "int b; // any comments\n" - "int c; // comment\n" - "int d;// comment", - Style); + verifyNoChange("int a; // do not touch\n" + "int b; // any comments\n" + "int c; // comment\n" + "int d;// comment", + Style); - verifyFormat("// do not touch\n" - "int a; // any comments\n" - "\n" - " // comment\n" - "// comment\n" - "\n" - "// comment", - "// do not touch\n" - "int a; // any comments\n" - "\n" - " // comment\n" - "// comment\n" - "\n" - "// comment", - Style); + verifyNoChange("// do not touch\n" + "int a; // any comments\n" + "\n" + " // comment\n" + "// comment\n" + "\n" + "// comment", + Style); verifyFormat("// do not touch\n" "int a; // any comments\n" @@ -3178,23 +3071,15 @@ TEST_F(FormatTestComments, AlignTrailingCommentsLeave) { // Allow to keep 2 empty lines Style.MaxEmptyLinesToKeep = 2; - verifyFormat("// do not touch\n" - "int a; // any comments\n" - "\n" - "\n" - " // comment\n" - "// comment\n" - "\n" - "// comment", - "// do not touch\n" - "int a; // any comments\n" - "\n" - "\n" - " // comment\n" - "// comment\n" - "\n" - "// comment", - Style); + verifyNoChange("// do not touch\n" + "int a; // any comments\n" + "\n" + "\n" + " // comment\n" + "// comment\n" + "\n" + "// comment", + Style); Style.MaxEmptyLinesToKeep = 1; // Just format comments normally when leaving exceeds the column limit @@ -3233,16 +3118,16 @@ TEST_F(FormatTestComments, DontAlignNamespaceComments) { Style.NamespaceMacros.push_back("TESTSUITE"); Style.ShortNamespaceLines = 0; - StringRef Input = "namespace A {\n" - " TESTSUITE(B) {\n" - " namespace C {\n" - " namespace D { //\n" - " } // namespace D\n" - " std::string Foo = Bar; // Comment\n" - " std::string BazString = Baz; // C2\n" - " } // namespace C\n" - " }\n" - "} // NaMeSpAcE A"; + constexpr StringRef Input("namespace A {\n" + " TESTSUITE(B) {\n" + " namespace C {\n" + " namespace D { //\n" + " } // namespace D\n" + " std::string Foo = Bar; // Comment\n" + " std::string BazString = Baz; // C2\n" + " } // namespace C\n" + " }\n" + "} // NaMeSpAcE A"); EXPECT_TRUE(Style.FixNamespaceComments); EXPECT_EQ(Style.AlignTrailingComments.Kind, FormatStyle::TCAS_Always); @@ -3326,21 +3211,21 @@ TEST_F(FormatTestComments, DontAlignNamespaceComments) { Style.AlignTrailingComments.Kind = FormatStyle::TCAS_Always; Style.FixNamespaceComments = true; - Input = "namespace A {\n" - " int Foo;\n" - " int Bar;\n" - "}\n" - "// Comment"; + constexpr StringRef Code("namespace A {\n" + " int Foo;\n" + " int Bar;\n" + "}\n" + "// Comment"); verifyFormat("namespace A {\n" " int Foo;\n" " int Bar;\n" "} // namespace A\n" "// Comment", - Input, Style); + Code, Style); Style.FixNamespaceComments = false; - verifyFormat(Input, Style); + verifyFormat(Code, Style); } TEST_F(FormatTestComments, DontAlignOverScope) { @@ -3498,10 +3383,8 @@ TEST_F(FormatTestComments, AlignsBlockCommentDecorations) { " */", "/*\n" "*/"); - verifyFormat("/*\n" - " */", - "/*\n" - " */"); + verifyNoChange("/*\n" + " */"); verifyFormat("/*\n" " */", "/*\n" @@ -3512,10 +3395,8 @@ TEST_F(FormatTestComments, AlignsBlockCommentDecorations) { " * line */", "/*\n" "* line */"); - verifyFormat("/*\n" - " * line */", - "/*\n" - " * line */"); + verifyNoChange("/*\n" + " * line */"); verifyFormat("/*\n" " * line */", "/*\n" @@ -3528,10 +3409,8 @@ TEST_F(FormatTestComments, AlignsBlockCommentDecorations) { " * line */", "/**\n" "* line */"); - verifyFormat("/**\n" - " * line */", - "/**\n" - " * line */"); + verifyNoChange("/**\n" + " * line */"); verifyFormat("/**\n" " * line */", "/**\n" @@ -3566,10 +3445,8 @@ TEST_F(FormatTestComments, AlignsBlockCommentDecorations) { " */"); // Align two lines. - verifyFormat("/* line 1\n" - " * line 2 */", - "/* line 1\n" - " * line 2 */"); + verifyNoChange("/* line 1\n" + " * line 2 */"); verifyFormat("/* line 1\n" " * line 2 */", "/* line 1\n" @@ -3590,10 +3467,8 @@ TEST_F(FormatTestComments, AlignsBlockCommentDecorations) { " * line 2 */", "int i; /* line 1\n" "* line 2 */"); - verifyFormat("int i; /* line 1\n" - " * line 2 */", - "int i; /* line 1\n" - " * line 2 */"); + verifyNoChange("int i; /* line 1\n" + " * line 2 */"); verifyFormat("int i; /* line 1\n" " * line 2 */", "int i; /* line 1\n" @@ -3695,6 +3570,7 @@ TEST_F(FormatTestComments, NonTrailingBlockComments) { TEST_F(FormatTestComments, PythonStyleComments) { const auto ProtoStyle20 = getTextProtoStyleWithColumns(20); + // Keeps a space after '#'. verifyFormat("# comment\n" "key: value", @@ -3798,8 +3674,6 @@ TEST_F(FormatTestComments, ReflowBackslashCrash) { TEST_F(FormatTestComments, IndentsLongJavadocAnnotatedLines) { FormatStyle Style = getGoogleStyle(FormatStyle::LK_Java); Style.ColumnLimit = 60; - FormatStyle Style20 = getGoogleStyle(FormatStyle::LK_Java); - Style20.ColumnLimit = 20; verifyFormat("/**\n" " * @param x long long long long long long long long long\n" " * long\n" @@ -3827,6 +3701,10 @@ TEST_F(FormatTestComments, IndentsLongJavadocAnnotatedLines) { "long long long long long long long long long long long\n" " */", Style); + + FormatStyle Style20 = getGoogleStyle(FormatStyle::LK_Java); + Style20.ColumnLimit = 20; + verifyFormat("/**\n" " * Sentence that\n" " * should be broken.\n" @@ -3895,7 +3773,6 @@ TEST_F(FormatTestComments, IndentsLongJavadocAnnotatedLines) { } TEST_F(FormatTestComments, SpaceAtLineCommentBegin) { - FormatStyle Style = getLLVMStyle(); constexpr StringRef NoTextInComment(" // \n" "\n" "void foo() {// \n" @@ -3907,8 +3784,9 @@ TEST_F(FormatTestComments, SpaceAtLineCommentBegin) { "void foo() { //\n" " //\n" "}", - NoTextInComment, Style); + NoTextInComment); + auto Style = getLLVMStyle(); Style.SpacesInLineCommentPrefix.Minimum = 0; verifyFormat("//#comment", Style); verifyFormat("//\n" @@ -3927,7 +3805,6 @@ TEST_F(FormatTestComments, SpaceAtLineCommentBegin) { "}", NoTextInComment, Style); - Style = getLLVMStyle(); constexpr StringRef Code( "//Free comment without space\n" "\n" @@ -4216,8 +4093,9 @@ TEST_F(FormatTestComments, SpaceAtLineCommentBegin) { "// vv will only move\n" "// } if the line above does"); - verifyFormat(Code2, Code, Style); + verifyFormat(Code2, Code); + Style = getLLVMStyle(); Style.SpacesInLineCommentPrefix = {0, 0}; verifyFormat("//#comment", "// #comment", Style); verifyFormat(Code3, Code, Style); @@ -4226,12 +4104,12 @@ TEST_F(FormatTestComments, SpaceAtLineCommentBegin) { verifyFormat(Code4, Code, Style); Style = getLLVMStyleWithColumns(20); - StringRef WrapCode = "//Lorem ipsum dolor sit amet\n" - "\n" - "// Lorem ipsum dolor sit amet\n" - "\n" - "void f() {//Hello World\n" - "}"; + constexpr StringRef WrapCode("//Lorem ipsum dolor sit amet\n" + "\n" + "// Lorem ipsum dolor sit amet\n" + "\n" + "void f() {//Hello World\n" + "}"); verifyFormat("// Lorem ipsum dolor\n" "// sit amet\n" @@ -4506,20 +4384,20 @@ TEST_F(FormatTestComments, SplitCommentIntroducers) { } TEST_F(FormatTestComments, LineCommentsOnStartOfFunctionCall) { - auto Style = getLLVMStyle(); - - EXPECT_EQ(Style.Cpp11BracedListStyle, FormatStyle::BLS_AlignFirstComment); verifyFormat("Type name{// Comment\n" - " value};", - Style); + " value};"); + auto Style = getLLVMStyle(); + EXPECT_EQ(Style.Cpp11BracedListStyle, FormatStyle::BLS_AlignFirstComment); Style.Cpp11BracedListStyle = FormatStyle::BLS_Block; + verifyFormat("Type name{ // Comment\n" " value\n" "};", Style); Style.Cpp11BracedListStyle = FormatStyle::BLS_FunctionCall; + verifyFormat("Type name{ // Comment\n" " value};", Style); diff --git a/clang/unittests/Format/TokenAnnotatorTest.cpp b/clang/unittests/Format/TokenAnnotatorTest.cpp index c046142..815c79e 100644 --- a/clang/unittests/Format/TokenAnnotatorTest.cpp +++ b/clang/unittests/Format/TokenAnnotatorTest.cpp @@ -799,6 +799,30 @@ TEST_F(TokenAnnotatorTest, UnderstandsTemplateTemplateParameters) { EXPECT_TOKEN(Tokens[23], tok::identifier, TT_ClassHeadName); } +TEST_F(TokenAnnotatorTest, UnderstandsCommonCppTemplates) { + auto Tokens = + annotate("static_assert(std::conditional_t<A || B, C, D>::value);"); + ASSERT_EQ(Tokens.size(), 19u) << Tokens; + EXPECT_TOKEN(Tokens[5], tok::less, TT_TemplateOpener); + EXPECT_TOKEN(Tokens[13], tok::greater, TT_TemplateCloser); + + Tokens = + annotate("static_assert(std::conditional<A || B, C, D>::type::value);"); + ASSERT_EQ(Tokens.size(), 21u) << Tokens; + EXPECT_TOKEN(Tokens[5], tok::less, TT_TemplateOpener); + EXPECT_TOKEN(Tokens[13], tok::greater, TT_TemplateCloser); + + Tokens = annotate("static_assert(fancy_v<A || B>);"); + ASSERT_EQ(Tokens.size(), 11u) << Tokens; + EXPECT_TOKEN(Tokens[3], tok::less, TT_TemplateOpener); + EXPECT_TOKEN(Tokens[7], tok::greater, TT_TemplateCloser); + + Tokens = annotate("static_assert(fancy<A || B>::value);"); + ASSERT_EQ(Tokens.size(), 13u) << Tokens; + EXPECT_TOKEN(Tokens[3], tok::less, TT_TemplateOpener); + EXPECT_TOKEN(Tokens[7], tok::greater, TT_TemplateCloser); +} + TEST_F(TokenAnnotatorTest, UnderstandsWhitespaceSensitiveMacros) { FormatStyle Style = getLLVMStyle(); Style.WhitespaceSensitiveMacros.push_back("FOO"); @@ -2686,6 +2710,7 @@ TEST_F(TokenAnnotatorTest, UnderstandsVerilogOperators) { // precedence. std::pair<prec::Level, std::string> JoinedBinary[] = { {prec::Comma, "->"}, {prec::Comma, "<->"}, + {prec::Comma, "#-#"}, {prec::Comma, "#=#"}, {prec::Assignment, "+="}, {prec::Assignment, "-="}, {prec::Assignment, "*="}, {prec::Assignment, "/="}, {prec::Assignment, "%="}, {prec::Assignment, "&="}, diff --git a/clang/www/c_status.html b/clang/www/c_status.html index b803962..80a52f7 100644 --- a/clang/www/c_status.html +++ b/clang/www/c_status.html @@ -329,7 +329,7 @@ conformance.</p> <tr> <td>The __COUNTER__ predefined macro</td> <td><a href="https://www.open-std.org/jtc1/sc22/wg14/www/docs/n3457.htm">N3457</a></td> - <td class="unknown" align="center">Unknown</td> + <td class="unreleased" align="center">Clang 22</td> </tr> <tr> <td>Chasing Ghosts I: constant expressions v2</td> diff --git a/clang/www/cxx_dr_status.html b/clang/www/cxx_dr_status.html index 0312c9d..e9fadb2 100755 --- a/clang/www/cxx_dr_status.html +++ b/clang/www/cxx_dr_status.html @@ -40,2843 +40,3314 @@ <p>This page tracks which C++ defect reports are implemented within Clang.</p> -<table width="689" border="1" cellspacing="0"> +<table width="892" border="1" cellspacing="0"> <tr> <th>Number</th> + <th>Section</th> <th>Status</th> <th>Issue title</th> <th>Available in Clang?</th> </tr> <tr id="1"> <td><a href="https://cplusplus.github.io/CWG/issues/1.html">1</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>TC1</td> <td>What if two using-declarations refer to the same function but the declarations introduce different default-arguments?</td> <td class="none" align="center">No</td> </tr> <tr class="open" id="2"> <td><a href="https://cplusplus.github.io/CWG/issues/2.html">2</a></td> + <td>[<a href="https://wg21.link/temp.dep.res">temp.dep.res</a>]</td> <td>drafting</td> <td>How can dependent names be used in member declarations that appear outside of the class template definition?</td> <td align="center">Not resolved</td> </tr> <tr id="3"> <td><a href="https://cplusplus.github.io/CWG/issues/3.html">3</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>NAD</td> <td>The template compilation model rules render some explicit specialization declarations not visible during instantiation</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="4"> <td><a href="https://cplusplus.github.io/CWG/issues/4.html">4</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>CD1</td> <td>Does extern "C" affect the linkage of function names with internal linkage?</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="5"> <td><a href="https://cplusplus.github.io/CWG/issues/5.html">5</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD1</td> <td>CV-qualifiers and type conversions</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="6"> <td><a href="https://cplusplus.github.io/CWG/issues/6.html">6</a></td> + <td>[<a href="https://wg21.link/class.copy.elision">class.copy.elision</a>]</td> <td>NAD</td> <td>Should the optimization that allows a class object to alias another object also allow the case of a parameter in an inline function to alias its argument?</td> <td class="full" align="center">Yes</td> </tr> <tr id="7"> <td><a href="https://cplusplus.github.io/CWG/issues/7.html">7</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>NAD</td> <td>Can a class with a private virtual base class be derived from?</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="8"> <td><a href="https://cplusplus.github.io/CWG/issues/8.html">8</a></td> + <td>[<a href="https://wg21.link/class.access">class.access</a>]</td> <td>CD1</td> <td>Access to template arguments used in a function return type and in the nested name specifier</td> <td class="full" align="center">Duplicate of <a href="#45">45</a></td> </tr> <tr id="9"> <td><a href="https://cplusplus.github.io/CWG/issues/9.html">9</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>CD1</td> <td>Clarification of access to base class members</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="10"> <td><a href="https://cplusplus.github.io/CWG/issues/10.html">10</a></td> + <td>[<a href="https://wg21.link/class.access.nest">class.access.nest</a>]</td> <td>CD1</td> <td>Can a nested class access its own class name as a qualified name if it is a private member of the enclosing class?</td> <td class="full" align="center">Duplicate of <a href="#45">45</a></td> </tr> <tr id="11"> <td><a href="https://cplusplus.github.io/CWG/issues/11.html">11</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD1</td> <td>How do the keywords typename/template interact with using-declarations?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="12"> <td><a href="https://cplusplus.github.io/CWG/issues/12.html">12</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>dup</td> <td>Default arguments on different declarations for the same function and the Koenig lookup</td> <td class="full-superseded" align="center">Superseded by <a href="#239">239</a></td> </tr> <tr id="13"> <td><a href="https://cplusplus.github.io/CWG/issues/13.html">13</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>NAD</td> <td>extern "C" for Parameters of Function Templates</td> <td class="none" align="center">No</td> </tr> <tr id="14"> <td><a href="https://cplusplus.github.io/CWG/issues/14.html">14</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>NAD</td> <td>extern "C" functions and declarations in different namespaces</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="15"> <td><a href="https://cplusplus.github.io/CWG/issues/15.html">15</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>dup</td> <td>Default arguments for parameters of function templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="16"> <td><a href="https://cplusplus.github.io/CWG/issues/16.html">16</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>CD1</td> <td>Access to members of indirect private base classes</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="17"> <td><a href="https://cplusplus.github.io/CWG/issues/17.html">17</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>NAD</td> <td>Footnote 99 should discuss the naming class when describing members that can be accessed from friends</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="18"> <td><a href="https://cplusplus.github.io/CWG/issues/18.html">18</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>NAD</td> <td>f(TYPE) where TYPE is void should be allowed</td> <td class="full-superseded" align="center">Superseded by <a href="#577">577</a></td> </tr> <tr id="19"> <td><a href="https://cplusplus.github.io/CWG/issues/19.html">19</a></td> + <td>[<a href="https://wg21.link/class.protected">class.protected</a>]</td> <td>NAD</td> <td>Clarify protected member access</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="20"> <td><a href="https://cplusplus.github.io/CWG/issues/20.html">20</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>TC1</td> <td>Some clarifications needed for 12.8 para 15</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="21"> <td><a href="https://cplusplus.github.io/CWG/issues/21.html">21</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>TC1</td> <td>Can a default argument for a template parameter appear in a friend declaration?</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="22"> <td><a href="https://cplusplus.github.io/CWG/issues/22.html">22</a></td> + <td>[<a href="https://wg21.link/temp.dep.res">temp.dep.res</a>]</td> <td>TC1</td> <td>Template parameter with a default argument that refers to itself</td> <td class="full-superseded" align="center">Superseded by <a href="#481">481</a></td> </tr> <tr id="23"> <td><a href="https://cplusplus.github.io/CWG/issues/23.html">23</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>NAD</td> <td>Some questions regarding partial ordering of function templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="24"> <td><a href="https://cplusplus.github.io/CWG/issues/24.html">24</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>TC1</td> <td>Errors in examples in 14.7.3</td> <td class="na" align="center">N/A</td> </tr> <tr id="25"> <td><a href="https://cplusplus.github.io/CWG/issues/25.html">25</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>TC1</td> <td>Exception specifications and pointers to members</td> <td class="full" align="center">Clang 4</td> </tr> <tr id="26"> <td><a href="https://cplusplus.github.io/CWG/issues/26.html">26</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>NAD</td> <td>Copy constructors and default arguments</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="27"> <td><a href="https://cplusplus.github.io/CWG/issues/27.html">27</a></td> + <td>[<a href="https://wg21.link/over.built">over.built</a>]</td> <td>NAD</td> <td>Overload ambiguities for builtin ?: prototypes</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="28"> <td><a href="https://cplusplus.github.io/CWG/issues/28.html">28</a></td> + <td>[<a href="https://wg21.link/basic.start.dynamic">basic.start.dynamic</a>]</td> <td>CD1</td> <td>'exit', 'signal' and static object destruction</td> <td class="na" align="center">N/A (Library DR)</td> </tr> <tr id="29"> <td><a href="https://cplusplus.github.io/CWG/issues/29.html">29</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>CD1</td> <td>Linkage of locally declared functions</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="30"> <td><a href="https://cplusplus.github.io/CWG/issues/30.html">30</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>TC1</td> <td>Valid uses of "<TT>::template</TT>"</td> <td class="full-superseded" align="center">Superseded by <a href="#468">468</a> (C++11 onwards)</td> </tr> <tr id="31"> <td><a href="https://cplusplus.github.io/CWG/issues/31.html">31</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>NAD</td> <td>Looking up new/delete</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="32"> <td><a href="https://cplusplus.github.io/CWG/issues/32.html">32</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>TC1</td> <td>Clarification of explicit instantiation of non-exported templates</td> <td class="na" align="center">N/A</td> </tr> <tr id="33"> <td><a href="https://cplusplus.github.io/CWG/issues/33.html">33</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>TC1</td> <td>Argument dependent lookup and overloaded functions</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="34"> <td><a href="https://cplusplus.github.io/CWG/issues/34.html">34</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>NAD</td> <td>Argument dependent lookup and points of instantiation</td> <td class="na" align="center">N/A</td> </tr> <tr id="35"> <td><a href="https://cplusplus.github.io/CWG/issues/35.html">35</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>TC1</td> <td>Definition of default-initialization</td> <td class="full" align="center">Duplicate of <a href="#178">178</a></td> </tr> <tr id="36"> <td><a href="https://cplusplus.github.io/CWG/issues/36.html">36</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD6</td> <td><I>using-declaration</I>s in multiple-declaration contexts</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="37"> <td><a href="https://cplusplus.github.io/CWG/issues/37.html">37</a></td> + <td>[<a href="https://wg21.link/except.uncaught">except.uncaught</a>]</td> <td>NAD</td> <td>When is uncaught_exception() true?</td> <td class="unknown-superseded" align="center">Superseded by <a href="#475">475</a></td> </tr> <tr id="38"> <td><a href="https://cplusplus.github.io/CWG/issues/38.html">38</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>TC1</td> <td>Explicit template arguments and operator functions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="39"> <td><a href="https://cplusplus.github.io/CWG/issues/39.html">39</a></td> + <td>[<a href="https://wg21.link/class.member.lookup">class.member.lookup</a>]</td> <td>CD1</td> <td>Conflicting ambiguity rules</td> <td class="none" align="center">No</td> </tr> <tr id="40"> <td><a href="https://cplusplus.github.io/CWG/issues/40.html">40</a></td> + <td>[<a href="https://wg21.link/dcl.meaning">dcl.meaning</a>]</td> <td>TC1</td> <td>Syntax of <I>declarator-id</I></td> <td class="na" align="center">N/A</td> </tr> <tr id="41"> <td><a href="https://cplusplus.github.io/CWG/issues/41.html">41</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>TC1</td> <td>Clarification of lookup of names after declarator-id</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="42"> <td><a href="https://cplusplus.github.io/CWG/issues/42.html">42</a></td> + <td>[<a href="https://wg21.link/basic.scope.class">basic.scope.class</a>]</td> <td>NAD</td> <td>Redefining names from base classes</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="43"> <td><a href="https://cplusplus.github.io/CWG/issues/43.html">43</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>TC1</td> <td>Copying base classes (PODs) using memcpy</td> <td class="na" align="center">N/A</td> </tr> <tr id="44"> <td><a href="https://cplusplus.github.io/CWG/issues/44.html">44</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>CD1</td> <td>Member specializations</td> <td class="partial-superseded" align="center">Superseded by <a href="#727">727</a></td> </tr> <tr id="45"> <td><a href="https://cplusplus.github.io/CWG/issues/45.html">45</a></td> + <td>[<a href="https://wg21.link/class.access.nest">class.access.nest</a>]</td> <td>CD1</td> <td>Access to nested classes</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="46"> <td><a href="https://cplusplus.github.io/CWG/issues/46.html">46</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>NAD</td> <td>Explicit instantiation of member templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="47"> <td><a href="https://cplusplus.github.io/CWG/issues/47.html">47</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>NAD</td> <td>Template friend issues</td> <td class="full-superseded" align="center">Superseded by <a href="#329">329</a></td> </tr> <tr id="48"> <td><a href="https://cplusplus.github.io/CWG/issues/48.html">48</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>TC1</td> <td>Definitions of unused static members</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="49"> <td><a href="https://cplusplus.github.io/CWG/issues/49.html">49</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>TC1</td> <td>Restriction on non-type, non-value template arguments</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="50"> <td><a href="https://cplusplus.github.io/CWG/issues/50.html">50</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>NAD</td> <td>Converting pointer to incomplete type to same type</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="51"> <td><a href="https://cplusplus.github.io/CWG/issues/51.html">51</a></td> + <td>[<a href="https://wg21.link/over.match.best">over.match.best</a>]</td> <td>TC1</td> <td>Overloading and user-defined conversions</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="52"> <td><a href="https://cplusplus.github.io/CWG/issues/52.html">52</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>TC1</td> <td>Non-static members, member selection and access checking</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="53"> <td><a href="https://cplusplus.github.io/CWG/issues/53.html">53</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>TC1</td> <td>Lvalue-to-rvalue conversion before certain static_casts</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="54"> <td><a href="https://cplusplus.github.io/CWG/issues/54.html">54</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD1</td> <td>Static_cast from private base to derived class</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="55"> <td><a href="https://cplusplus.github.io/CWG/issues/55.html">55</a></td> + <td>[<a href="https://wg21.link/expr.add">expr.add</a>]</td> <td>NAD</td> <td>Adding/subtracting pointer and enumeration value</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="56"> <td><a href="https://cplusplus.github.io/CWG/issues/56.html">56</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>TC1</td> <td>Redeclaring typedefs within classes</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="57"> <td><a href="https://cplusplus.github.io/CWG/issues/57.html">57</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>open</td> <td>Empty unions</td> <td align="center">Not resolved</td> </tr> <tr id="58"> <td><a href="https://cplusplus.github.io/CWG/issues/58.html">58</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>CD1</td> <td>Signedness of bit fields of enum type</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="59"> <td><a href="https://cplusplus.github.io/CWG/issues/59.html">59</a></td> + <td>[<a href="https://wg21.link/over.match.copy">over.match.copy</a>]</td> <td>TC1</td> <td>Clarification of overloading and UDC to reference type</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="60"> <td><a href="https://cplusplus.github.io/CWG/issues/60.html">60</a></td> + <td>[<a href="https://wg21.link/over.ics.ref">over.ics.ref</a>]</td> <td>CD1</td> <td>Reference binding and valid conversion sequences</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="61"> <td><a href="https://cplusplus.github.io/CWG/issues/61.html">61</a></td> + <td>[<a href="https://wg21.link/over.over">over.over</a>]</td> <td>NAD</td> <td>Address of static member function "<TT>&p->f</TT>"</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="62"> <td><a href="https://cplusplus.github.io/CWG/issues/62.html">62</a></td> + <td>[<a href="https://wg21.link/temp.arg.type">temp.arg.type</a>]</td> <td>CD1</td> <td>Unnamed members of classes used as type parameters</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="63"> <td><a href="https://cplusplus.github.io/CWG/issues/63.html">63</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>CD1</td> <td>Class instantiation from pointer conversion to void*, null and self</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="64"> <td><a href="https://cplusplus.github.io/CWG/issues/64.html">64</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>TC1</td> <td>Partial ordering to disambiguate explicit specialization</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="65"> <td><a href="https://cplusplus.github.io/CWG/issues/65.html">65</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>TC1</td> <td>Typo in default argument example</td> <td class="na" align="center">N/A</td> </tr> <tr id="66"> <td><a href="https://cplusplus.github.io/CWG/issues/66.html">66</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>NAD</td> <td>Visibility of default args vs overloads added after using-declaration</td> <td class="none" align="center">No</td> </tr> <tr id="67"> <td><a href="https://cplusplus.github.io/CWG/issues/67.html">67</a></td> + <td>[<a href="https://wg21.link/class.static">class.static</a>]</td> <td>TC1</td> <td>Evaluation of left side of object-expression</td> <td class="na" align="center">N/A</td> </tr> <tr id="68"> <td><a href="https://cplusplus.github.io/CWG/issues/68.html">68</a></td> + <td>[<a href="https://wg21.link/dcl.type.elab">dcl.type.elab</a>]</td> <td>TC1</td> <td>Grammar does not allow "friend class A<int>;"</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="69"> <td><a href="https://cplusplus.github.io/CWG/issues/69.html">69</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>TC1</td> <td>Storage class specifiers on template declarations</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="70"> <td><a href="https://cplusplus.github.io/CWG/issues/70.html">70</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>CD1</td> <td>Is an array bound a nondeduced context?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="71"> <td><a href="https://cplusplus.github.io/CWG/issues/71.html">71</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>NAD</td> <td>Incorrect cross reference</td> <td class="na" align="center">N/A</td> </tr> <tr id="72"> <td><a href="https://cplusplus.github.io/CWG/issues/72.html">72</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>dup</td> <td>Linkage and storage class specifiers for templates</td> <td class="full" align="center">Duplicate of <a href="#69">69</a></td> </tr> <tr id="73"> <td><a href="https://cplusplus.github.io/CWG/issues/73.html">73</a></td> + <td>[<a href="https://wg21.link/expr.eq">expr.eq</a>]</td> <td>TC1</td> <td>Pointer equality</td> <td class="full-superseded" align="center">Superseded by <a href="#1652">1652</a></td> </tr> <tr id="74"> <td><a href="https://cplusplus.github.io/CWG/issues/74.html">74</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>TC1</td> <td>Enumeration value in direct-new-declarator</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="75"> <td><a href="https://cplusplus.github.io/CWG/issues/75.html">75</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>TC1</td> <td>In-class initialized members must be const</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="76"> <td><a href="https://cplusplus.github.io/CWG/issues/76.html">76</a></td> + <td>[<a href="https://wg21.link/dcl.type.cv">dcl.type.cv</a>]</td> <td>TC1</td> <td>Are const volatile variables considered "constant expressions"?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="77"> <td><a href="https://cplusplus.github.io/CWG/issues/77.html">77</a></td> + <td>[<a href="https://wg21.link/class.friend">class.friend</a>]</td> <td>CD1</td> <td>The definition of friend does not allow nested classes to be friends</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="78"> <td><a href="https://cplusplus.github.io/CWG/issues/78.html">78</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD1</td> <td>Section 8.5 paragraph 9 should state it only applies to non-static objects</td> <td class="none" align="center">Superseded by <a href="#????">????</a></td> </tr> <tr id="79"> <td><a href="https://cplusplus.github.io/CWG/issues/79.html">79</a></td> + <td>[<a href="https://wg21.link/new.delete.placement">new.delete.placement</a>]</td> <td>dup</td> <td>Alignment and placement new</td> <td class="na" align="center">N/A</td> </tr> <tr id="80"> <td><a href="https://cplusplus.github.io/CWG/issues/80.html">80</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>TC1</td> <td>Class members with same name as class</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="81"> <td><a href="https://cplusplus.github.io/CWG/issues/81.html">81</a></td> + <td>[<a href="https://wg21.link/diff">diff</a>]</td> <td>NAD</td> <td>Null pointers and C compatibility</td> <td class="na" align="center">N/A</td> </tr> <tr id="82"> <td><a href="https://cplusplus.github.io/CWG/issues/82.html">82</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>dup</td> <td>Definition of "using" a constant expression</td> <td class="full" align="center">Duplicate of <a href="#48">48</a></td> </tr> <tr id="83"> <td><a href="https://cplusplus.github.io/CWG/issues/83.html">83</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>TC1</td> <td>Overloading and deprecated conversion of string literal</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="84"> <td><a href="https://cplusplus.github.io/CWG/issues/84.html">84</a></td> + <td>[<a href="https://wg21.link/over.best.ics">over.best.ics</a>]</td> <td>TC1</td> <td>Overloading and conversion loophole used by <TT>auto_ptr</TT></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="85"> <td><a href="https://cplusplus.github.io/CWG/issues/85.html">85</a></td> + <td>[<a href="https://wg21.link/basic.lookup.elab">basic.lookup.elab</a>]</td> <td>TC1</td> <td>Redeclaration of member class</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="86"> <td><a href="https://cplusplus.github.io/CWG/issues/86.html">86</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD1</td> <td>Lifetime of temporaries in query expressions</td> <td class="full" align="center">Duplicate of <a href="#446">446</a></td> </tr> <tr id="87"> <td><a href="https://cplusplus.github.io/CWG/issues/87.html">87</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD1</td> <td>Exception specifications on function parameters</td> <td class="none" align="center">No</td> </tr> <tr id="88"> <td><a href="https://cplusplus.github.io/CWG/issues/88.html">88</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>NAD</td> <td>Specialization of member constant templates</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="89"> <td><a href="https://cplusplus.github.io/CWG/issues/89.html">89</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>TC1</td> <td>Object lifetime does not account for reference rebinding</td> <td class="na" align="center">N/A</td> </tr> <tr id="90"> <td><a href="https://cplusplus.github.io/CWG/issues/90.html">90</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>TC1</td> <td>Should the enclosing class be an "associated class" too?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="91"> <td><a href="https://cplusplus.github.io/CWG/issues/91.html">91</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>NAD</td> <td>A union's associated types should include the union itself</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="92"> <td><a href="https://cplusplus.github.io/CWG/issues/92.html">92</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD4</td> <td>Should <I>exception-specification</I>s be part of the type system?</td> <td class="full" align="center">Clang 4 (C++17 onwards)</td> </tr> <tr id="93"> <td><a href="https://cplusplus.github.io/CWG/issues/93.html">93</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>TC1</td> <td>Missing word in 3.8 <U>basic.life</U> paragraph 2</td> <td class="na" align="center">N/A</td> </tr> <tr id="94"> <td><a href="https://cplusplus.github.io/CWG/issues/94.html">94</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>TC1</td> <td>Inconsistencies in the descriptions of constant expressions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="95"> <td><a href="https://cplusplus.github.io/CWG/issues/95.html">95</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>NAD</td> <td>Elaborated type specifiers referencing names declared in friend decls</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr id="96"> <td><a href="https://cplusplus.github.io/CWG/issues/96.html">96</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>C++11</td> <td>Syntactic disambiguation using the <TT>template</TT> keyword</td> <td class="na" align="center">Superseded by <a href="https://wg21.link/P1787">P1787</a></td> </tr> <tr id="97"> <td><a href="https://cplusplus.github.io/CWG/issues/97.html">97</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td>Use of bool constants in integral constant expressions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="98"> <td><a href="https://cplusplus.github.io/CWG/issues/98.html">98</a></td> + <td>[<a href="https://wg21.link/except">except</a>]</td> <td>TC1</td> <td>Branching into try block</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="99"> <td><a href="https://cplusplus.github.io/CWG/issues/99.html">99</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>NAD</td> <td>Partial ordering, references and cv-qualifiers</td> <td class="full-superseded" align="center">Superseded by <a href="#214">214</a></td> </tr> <tr id="100"> <td><a href="https://cplusplus.github.io/CWG/issues/100.html">100</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>TC1</td> <td>Clarify why string literals are not allowed as template arguments</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="101"> <td><a href="https://cplusplus.github.io/CWG/issues/101.html">101</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>TC1</td> <td>Redeclaration of extern "C" names via using-declarations</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="102"> <td><a href="https://cplusplus.github.io/CWG/issues/102.html">102</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>NAD</td> <td>Operator lookup rules do not work well with parts of the library</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="103"> <td><a href="https://cplusplus.github.io/CWG/issues/103.html">103</a></td> + <td>[<a href="https://wg21.link/namespace.udir">namespace.udir</a>]</td> <td>TC1</td> <td>Is it <I>extended-namespace-definition</I> or <I>extension-namespace-definition</I> ?</td> <td class="na" align="center">N/A</td> </tr> <tr id="104"> <td><a href="https://cplusplus.github.io/CWG/issues/104.html">104</a></td> + <td>[<a href="https://wg21.link/except.throw">except.throw</a>]</td> <td>NAD</td> <td>Destroying the exception temp when no handler is found</td> <td class="na" align="center">N/A (Library DR)</td> </tr> <tr id="105"> <td><a href="https://cplusplus.github.io/CWG/issues/105.html">105</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>TC1</td> <td>Meaning of "template function"</td> <td class="na" align="center">N/A</td> </tr> <tr id="106"> <td><a href="https://cplusplus.github.io/CWG/issues/106.html">106</a></td> + <td>[<a href="https://wg21.link/unknown">unknown</a>]</td> <td>CD1</td> <td>Creating references to references during template deduction/instantiation</td> <td class="full-superseded" align="center">Superseded by <a href="#540">540</a></td> </tr> <tr id="107"> <td><a href="https://cplusplus.github.io/CWG/issues/107.html">107</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>NAD</td> <td>Linkage of operator functions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="108"> <td><a href="https://cplusplus.github.io/CWG/issues/108.html">108</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>TC1</td> <td>Are classes nested in templates dependent?</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="109"> <td><a href="https://cplusplus.github.io/CWG/issues/109.html">109</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>NAD</td> <td>Allowing <TT>::template</TT> in <I>using-declaration</I>s</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="110"> <td><a href="https://cplusplus.github.io/CWG/issues/110.html">110</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>CD6</td> <td>Can template functions and classes be declared in the same scope?</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="111"> <td><a href="https://cplusplus.github.io/CWG/issues/111.html">111</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>NAD</td> <td>Copy constructors and cv-qualifiers</td> <td class="full" align="center">Duplicate of <a href="#535">535</a></td> </tr> <tr id="112"> <td><a href="https://cplusplus.github.io/CWG/issues/112.html">112</a></td> + <td>[<a href="https://wg21.link/dcl.array">dcl.array</a>]</td> <td>CD1</td> <td>Array types and cv-qualifiers</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="113"> <td><a href="https://cplusplus.github.io/CWG/issues/113.html">113</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD1</td> <td>Visibility of called function</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="114"> <td><a href="https://cplusplus.github.io/CWG/issues/114.html">114</a></td> + <td>[<a href="https://wg21.link/temp.mem">temp.mem</a>]</td> <td>NAD</td> <td>Virtual overriding by template member function specializations</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="115"> <td><a href="https://cplusplus.github.io/CWG/issues/115.html">115</a></td> + <td>[<a href="https://wg21.link/over.over">over.over</a>]</td> <td>CD1</td> <td>Address of template-id</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="116"> <td><a href="https://cplusplus.github.io/CWG/issues/116.html">116</a></td> + <td>[<a href="https://wg21.link/temp.over.link">temp.over.link</a>]</td> <td>TC1</td> <td>Equivalent and functionally-equivalent function templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="117"> <td><a href="https://cplusplus.github.io/CWG/issues/117.html">117</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>NAD</td> <td>Timing of destruction of temporaries</td> <td class="na" align="center">N/A</td> </tr> <tr id="118"> <td><a href="https://cplusplus.github.io/CWG/issues/118.html">118</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD1</td> <td>Calls via pointers to virtual member functions</td> <td class="full" align="center">Yes</td> </tr> <tr id="119"> <td><a href="https://cplusplus.github.io/CWG/issues/119.html">119</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD1</td> <td>Object lifetime and aggregate initialization</td> <td class="na" align="center">N/A</td> </tr> <tr id="120"> <td><a href="https://cplusplus.github.io/CWG/issues/120.html">120</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>TC1</td> <td>Nonexistent non-terminal <I>qualified-name</I></td> <td class="na" align="center">N/A</td> </tr> <tr id="121"> <td><a href="https://cplusplus.github.io/CWG/issues/121.html">121</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>TC1</td> <td>Dependent type names with non-dependent <I>nested-name-specifier</I>s</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="122"> <td><a href="https://cplusplus.github.io/CWG/issues/122.html">122</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>CD1</td> <td><I>template-id</I>s as <I>unqualified-id</I>s</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="123"> <td><a href="https://cplusplus.github.io/CWG/issues/123.html">123</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>TC1</td> <td>Bad cross-reference</td> <td class="na" align="center">N/A</td> </tr> <tr id="124"> <td><a href="https://cplusplus.github.io/CWG/issues/124.html">124</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD1</td> <td>Lifetime of temporaries in default initialization of class arrays</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="125"> <td><a href="https://cplusplus.github.io/CWG/issues/125.html">125</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>CD1</td> <td>Ambiguity in <TT>friend</TT> declaration syntax</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="126"> <td><a href="https://cplusplus.github.io/CWG/issues/126.html">126</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>TC1</td> <td>Exception specifications and <TT>const</TT></td> <td class="partial" align="center">Partial</td> </tr> <tr id="127"> <td><a href="https://cplusplus.github.io/CWG/issues/127.html">127</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>TC1</td> <td>Ambiguity in description of matching deallocation function</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="128"> <td><a href="https://cplusplus.github.io/CWG/issues/128.html">128</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>TC1</td> <td>Casting between enum types</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="129"> <td><a href="https://cplusplus.github.io/CWG/issues/129.html">129</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>CD3</td> <td>Stability of uninitialized auto variables</td> <td class="full" align="center">Duplicate of <a href="#616">616</a></td> </tr> <tr id="130"> <td><a href="https://cplusplus.github.io/CWG/issues/130.html">130</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>NAD</td> <td>Sequence points and <I>new-expression</I>s</td> <td class="na" align="center">N/A</td> </tr> <tr id="131"> <td><a href="https://cplusplus.github.io/CWG/issues/131.html">131</a></td> + <td>[<a href="https://wg21.link/extendid">extendid</a>]</td> <td>TC1</td> <td>Typo in Lao characters</td> <td class="na" align="center">Superseded by <a href="https://wg21.link/P1949">P1949</a></td> </tr> <tr id="132"> <td><a href="https://cplusplus.github.io/CWG/issues/132.html">132</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>NAD</td> <td>Local types and linkage</td> <td class="none" align="center">No</td> </tr> <tr id="133"> <td><a href="https://cplusplus.github.io/CWG/issues/133.html">133</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>dup</td> <td>Exception specifications and checking</td> <td class="none" align="center">Duplicate of <a href="#87">87</a></td> </tr> <tr id="134"> <td><a href="https://cplusplus.github.io/CWG/issues/134.html">134</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>TC1</td> <td>Template classes and <I>declarator-id</I>s</td> <td class="na" align="center">N/A</td> </tr> <tr id="135"> <td><a href="https://cplusplus.github.io/CWG/issues/135.html">135</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>TC1</td> <td>Class type in in-class member function definitions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="136"> <td><a href="https://cplusplus.github.io/CWG/issues/136.html">136</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>CD1</td> <td>Default arguments and friend declarations</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="137"> <td><a href="https://cplusplus.github.io/CWG/issues/137.html">137</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>TC1</td> <td><TT>static_cast</TT> of <I>cv</I> <TT>void*</TT></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="138"> <td><a href="https://cplusplus.github.io/CWG/issues/138.html">138</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>CD6</td> <td>Friend declaration name lookup</td> <td class="partial" align="center">Partial</td> </tr> <tr id="139"> <td><a href="https://cplusplus.github.io/CWG/issues/139.html">139</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>CD1</td> <td>Error in <TT>friend</TT> lookup example</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="140"> <td><a href="https://cplusplus.github.io/CWG/issues/140.html">140</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD1</td> <td>Agreement of parameter declarations</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="141"> <td><a href="https://cplusplus.github.io/CWG/issues/141.html">141</a></td> + <td>[<a href="https://wg21.link/basic.lookup.classref">basic.lookup.classref</a>]</td> <td>CD1</td> <td>Non-member function templates in member access expressions</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="142"> <td><a href="https://cplusplus.github.io/CWG/issues/142.html">142</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>TC1</td> <td>Injection-related errors in access example</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="143"> <td><a href="https://cplusplus.github.io/CWG/issues/143.html">143</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>CD1</td> <td>Friends and Koenig lookup</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="144"> <td><a href="https://cplusplus.github.io/CWG/issues/144.html">144</a></td> + <td>[<a href="https://wg21.link/dcl.type.elab">dcl.type.elab</a>]</td> <td>open</td> <td>Position of <TT>friend</TT> specifier</td> <td align="center">Not resolved</td> </tr> <tr id="145"> <td><a href="https://cplusplus.github.io/CWG/issues/145.html">145</a></td> + <td>[<a href="https://wg21.link/depr.impldec">depr.impldec</a>]</td> <td>TC1</td> <td>Deprecation of prefix <TT>++</TT></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="146"> <td><a href="https://cplusplus.github.io/CWG/issues/146.html">146</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>open</td> <td>Floating-point zero</td> <td align="center">Not resolved</td> </tr> <tr id="147"> <td><a href="https://cplusplus.github.io/CWG/issues/147.html">147</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>TC1</td> <td>Naming the constructor</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="148"> <td><a href="https://cplusplus.github.io/CWG/issues/148.html">148</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>TC1</td> <td>POD classes and pointers to members</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="149"> <td><a href="https://cplusplus.github.io/CWG/issues/149.html">149</a></td> + <td>[<a href="https://wg21.link/conv.ptr">conv.ptr</a>]</td> <td>TC1</td> <td>Accessibility and ambiguity</td> <td class="na" align="center">N/A</td> </tr> <tr id="150"> <td><a href="https://cplusplus.github.io/CWG/issues/150.html">150</a></td> + <td>[<a href="https://wg21.link/temp.arg.template">temp.arg.template</a>]</td> <td>C++17</td> <td>Template template parameters and default arguments</td> <td class="full" align="center">Clang 19</td> </tr> <tr id="151"> <td><a href="https://cplusplus.github.io/CWG/issues/151.html">151</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>TC1</td> <td>Terminology of zero-initialization</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="152"> <td><a href="https://cplusplus.github.io/CWG/issues/152.html">152</a></td> + <td>[<a href="https://wg21.link/class.conv.ctor">class.conv.ctor</a>]</td> <td>TC1</td> <td><TT>explicit</TT> copy constructors</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="153"> <td><a href="https://cplusplus.github.io/CWG/issues/153.html">153</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>TC1</td> <td>Misleading wording (rank of conversion)</td> <td class="na" align="center">N/A</td> </tr> <tr id="154"> <td><a href="https://cplusplus.github.io/CWG/issues/154.html">154</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>NAD</td> <td>Anonymous unions in unnamed namespaces</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="155"> <td><a href="https://cplusplus.github.io/CWG/issues/155.html">155</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>dup</td> <td>Brace initializer for scalar</td> <td class="full" align="center">Duplicate of <a href="#632">632</a></td> </tr> <tr id="156"> <td><a href="https://cplusplus.github.io/CWG/issues/156.html">156</a></td> + <td>[<a href="https://wg21.link/basic.lookup.classref">basic.lookup.classref</a>]</td> <td>NAD</td> <td>Name lookup for conversion functions</td> <td class="partial-superseded" align="center">Superseded by <a href="#1111">1111</a></td> </tr> <tr class="open" id="157"> <td><a href="https://cplusplus.github.io/CWG/issues/157.html">157</a></td> + <td>[<a href="https://wg21.link/dcl.pre">dcl.pre</a>]</td> <td>open</td> <td>Omitted typedef declarator</td> <td align="center">Not resolved</td> </tr> <tr id="158"> <td><a href="https://cplusplus.github.io/CWG/issues/158.html">158</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>CD1</td> <td>Aliasing and qualification conversions</td> <td class="full" align="center">Yes</td> </tr> <tr id="159"> <td><a href="https://cplusplus.github.io/CWG/issues/159.html">159</a></td> + <td>[<a href="https://wg21.link/dcl.meaning">dcl.meaning</a>]</td> <td>TC1</td> <td>Namespace qualification in declarators</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="160"> <td><a href="https://cplusplus.github.io/CWG/issues/160.html">160</a></td> + <td>[<a href="https://wg21.link/dcl.ambig.res">dcl.ambig.res</a>]</td> <td>CD1</td> <td>Missing <TT>std::</TT> qualification</td> <td class="na" align="center">N/A</td> </tr> <tr id="161"> <td><a href="https://cplusplus.github.io/CWG/issues/161.html">161</a></td> + <td>[<a href="https://wg21.link/class.protected">class.protected</a>]</td> <td>TC1</td> <td>Access to protected nested type</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="162"> <td><a href="https://cplusplus.github.io/CWG/issues/162.html">162</a></td> + <td>[<a href="https://wg21.link/over.match.call">over.match.call</a>]</td> <td>CD1</td> <td>(<TT>&C::f)()</TT> with nonstatic members</td> <td class="full" align="center">Clang 19</td> </tr> <tr id="163"> <td><a href="https://cplusplus.github.io/CWG/issues/163.html">163</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>TC1</td> <td>Description of subaggregate initializer</td> <td class="na" align="center">N/A</td> </tr> <tr id="164"> <td><a href="https://cplusplus.github.io/CWG/issues/164.html">164</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>TC1</td> <td>Overlap between Koenig and normal lookup</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="165"> <td><a href="https://cplusplus.github.io/CWG/issues/165.html">165</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>NAD</td> <td>Definitions of friends and block-scope externs</td> <td class="none" align="center">No</td> </tr> <tr id="166"> <td><a href="https://cplusplus.github.io/CWG/issues/166.html">166</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>TC1</td> <td>Friend declarations of <I>template-id</I>s</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="167"> <td><a href="https://cplusplus.github.io/CWG/issues/167.html">167</a></td> + <td>[<a href="https://wg21.link/depr.static">depr.static</a>]</td> <td>NAD</td> <td>Deprecating static functions</td> <td class="unknown-superseded" align="center">Superseded by <a href="#1012">1012</a></td> </tr> <tr id="168"> <td><a href="https://cplusplus.github.io/CWG/issues/168.html">168</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>NAD</td> <td>C linkage for static member functions</td> <td class="none" align="center">No</td> </tr> <tr id="169"> <td><a href="https://cplusplus.github.io/CWG/issues/169.html">169</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>NAD</td> <td><I>template-id</I>s in <I>using-declaration</I>s</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="170"> <td><a href="https://cplusplus.github.io/CWG/issues/170.html">170</a></td> + <td>[<a href="https://wg21.link/conv.mem">conv.mem</a>]</td> <td>CD7</td> <td>Pointer-to-member conversions</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="171"> <td><a href="https://cplusplus.github.io/CWG/issues/171.html">171</a></td> + <td>[<a href="https://wg21.link/basic.namespace">basic.namespace</a>]</td> <td>TC1</td> <td>Global namespace scope</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="172"> <td><a href="https://cplusplus.github.io/CWG/issues/172.html">172</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD1</td> <td>Unsigned int as underlying type of enum</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="173"> <td><a href="https://cplusplus.github.io/CWG/issues/173.html">173</a></td> + <td>[<a href="https://wg21.link/lex.charset">lex.charset</a>]</td> <td>TC1</td> <td>Constraints on execution character set</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="174"> <td><a href="https://cplusplus.github.io/CWG/issues/174.html">174</a></td> + <td>[<a href="https://wg21.link/depr.static">depr.static</a>]</td> <td>NAD</td> <td>Undeprecating global static</td> <td class="unknown-superseded" align="center">Superseded by <a href="#1012">1012</a></td> </tr> <tr id="175"> <td><a href="https://cplusplus.github.io/CWG/issues/175.html">175</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD1</td> <td>Class name injection and base name access</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="176"> <td><a href="https://cplusplus.github.io/CWG/issues/176.html">176</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>TC1</td> <td>Name injection and templates</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="177"> <td><a href="https://cplusplus.github.io/CWG/issues/177.html">177</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD1</td> <td>Lvalues vs rvalues in copy-initialization</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="178"> <td><a href="https://cplusplus.github.io/CWG/issues/178.html">178</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>TC1</td> <td>More on value-initialization</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="179"> <td><a href="https://cplusplus.github.io/CWG/issues/179.html">179</a></td> + <td>[<a href="https://wg21.link/expr.add">expr.add</a>]</td> <td>TC1</td> <td>Function pointers and subtraction</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="180"> <td><a href="https://cplusplus.github.io/CWG/issues/180.html">180</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>CD1</td> <td><TT>typename</TT> and elaborated types</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="181"> <td><a href="https://cplusplus.github.io/CWG/issues/181.html">181</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>TC1</td> <td>Errors in template <I>template-parameter</I> example</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="182"> <td><a href="https://cplusplus.github.io/CWG/issues/182.html">182</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>NAD</td> <td>Access checking on explicit specializations</td> <td class="full" align="center">Clang 14</td> </tr> <tr id="183"> <td><a href="https://cplusplus.github.io/CWG/issues/183.html">183</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>TC1</td> <td><TT>typename</TT> in explicit specializations</td> <td class="full-superseded" align="center">Superseded by <a href="#382">382</a></td> </tr> <tr id="184"> <td><a href="https://cplusplus.github.io/CWG/issues/184.html">184</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>CD1</td> <td>Default arguments in template <I>template-parameter</I>s</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="185"> <td><a href="https://cplusplus.github.io/CWG/issues/185.html">185</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>TC1</td> <td>"Named" temporaries and copy elision</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="186"> <td><a href="https://cplusplus.github.io/CWG/issues/186.html">186</a></td> + <td>[<a href="https://wg21.link/temp.local">temp.local</a>]</td> <td>open</td> <td>Name hiding and template <I>template-parameter</I>s</td> <td align="center">Not resolved</td> </tr> <tr id="187"> <td><a href="https://cplusplus.github.io/CWG/issues/187.html">187</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>TC1</td> <td>Scope of template parameter names</td> <td class="full-superseded" align="center">Superseded by <a href="#481">481</a></td> </tr> <tr id="188"> <td><a href="https://cplusplus.github.io/CWG/issues/188.html">188</a></td> + <td>[<a href="https://wg21.link/expr.comma">expr.comma</a>]</td> <td>TC1</td> <td>Comma operator and rvalue conversion</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="189"> <td><a href="https://cplusplus.github.io/CWG/issues/189.html">189</a></td> + <td>[<a href="https://wg21.link/lex.operators">lex.operators</a>]</td> <td>open</td> <td>Definition of <I>operator</I> and <I>punctuator</I></td> <td align="center">Not resolved</td> </tr> <tr id="190"> <td><a href="https://cplusplus.github.io/CWG/issues/190.html">190</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>TC1</td> <td>Layout-compatible POD-struct types</td> <td class="full" align="center">Clang 19</td> </tr> <tr id="191"> <td><a href="https://cplusplus.github.io/CWG/issues/191.html">191</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>CD6</td> <td>Name lookup does not handle complex nesting</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="192"> <td><a href="https://cplusplus.github.io/CWG/issues/192.html">192</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>NAD</td> <td>Name lookup in parameters</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="193"> <td><a href="https://cplusplus.github.io/CWG/issues/193.html">193</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>TC1</td> <td>Order of destruction of local automatics of destructor</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="194"> <td><a href="https://cplusplus.github.io/CWG/issues/194.html">194</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>TC1</td> <td>Identifying constructors</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="195"> <td><a href="https://cplusplus.github.io/CWG/issues/195.html">195</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>CD1</td> <td>Converting between function and object pointers</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="196"> <td><a href="https://cplusplus.github.io/CWG/issues/196.html">196</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>open</td> <td>Arguments to deallocation functions</td> <td align="center">Not resolved</td> </tr> <tr id="197"> <td><a href="https://cplusplus.github.io/CWG/issues/197.html">197</a></td> + <td>[<a href="https://wg21.link/temp.dep.candidate">temp.dep.candidate</a>]</td> <td>CD1</td> <td>Issues with two-stage lookup of dependent names</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="198"> <td><a href="https://cplusplus.github.io/CWG/issues/198.html">198</a></td> + <td>[<a href="https://wg21.link/class.local">class.local</a>]</td> <td>CD1</td> <td>Definition of "use" in local and nested classes</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="199"> <td><a href="https://cplusplus.github.io/CWG/issues/199.html">199</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD1</td> <td>Order of destruction of temporaries</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="200"> <td><a href="https://cplusplus.github.io/CWG/issues/200.html">200</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>dup</td> <td>Partial ordering and explicit arguments</td> <td class="full" align="center">Duplicate of <a href="#214">214</a></td> </tr> <tr id="201"> <td><a href="https://cplusplus.github.io/CWG/issues/201.html">201</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD1</td> <td>Order of destruction of temporaries in initializers</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="202"> <td><a href="https://cplusplus.github.io/CWG/issues/202.html">202</a></td> + <td>[<a href="https://wg21.link/over.over">over.over</a>]</td> <td>TC1</td> <td>Use of overloaded function name</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="203"> <td><a href="https://cplusplus.github.io/CWG/issues/203.html">203</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>NAD</td> <td>Type of address-of-member expression</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="204"> <td><a href="https://cplusplus.github.io/CWG/issues/204.html">204</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>CD1</td> <td>Exported class templates</td> <td class="full-superseded" align="center">Superseded by <a href="#820">820</a></td> </tr> <tr class="open" id="205"> <td><a href="https://cplusplus.github.io/CWG/issues/205.html">205</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>drafting</td> <td>Templates and static data members</td> <td align="center">Not resolved</td> </tr> <tr id="206"> <td><a href="https://cplusplus.github.io/CWG/issues/206.html">206</a></td> + <td>[<a href="https://wg21.link/temp.nondep">temp.nondep</a>]</td> <td>TC1</td> <td>Semantic constraints on non-dependent names</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="207"> <td><a href="https://cplusplus.github.io/CWG/issues/207.html">207</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>CD1</td> <td><I>using-declaration</I>s and protected access</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="208"> <td><a href="https://cplusplus.github.io/CWG/issues/208.html">208</a></td> + <td>[<a href="https://wg21.link/except.throw">except.throw</a>]</td> <td>CD1</td> <td>Rethrowing exceptions in nested handlers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="209"> <td><a href="https://cplusplus.github.io/CWG/issues/209.html">209</a></td> + <td>[<a href="https://wg21.link/class.friend">class.friend</a>]</td> <td>NAD</td> - <td>Must friend declaration names be -accessible?</td> + <td>Must friend declaration names be accessible?</td> <td class="full" align="center">Clang 3.2</td> </tr> <tr id="210"> <td><a href="https://cplusplus.github.io/CWG/issues/210.html">210</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>TC1</td> <td>What is the type matched by an exception handler?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="211"> <td><a href="https://cplusplus.github.io/CWG/issues/211.html">211</a></td> + <td>[<a href="https://wg21.link/except">except</a>]</td> <td>NAD</td> <td>Constructors should not be allowed to return normally after an exception</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="212"> <td><a href="https://cplusplus.github.io/CWG/issues/212.html">212</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>CD4</td> <td>Implicit instantiation is not described clearly enough</td> <td class="full" align="center">Yes</td> </tr> <tr id="213"> <td><a href="https://cplusplus.github.io/CWG/issues/213.html">213</a></td> + <td>[<a href="https://wg21.link/temp.dep">temp.dep</a>]</td> <td>TC1</td> <td>Lookup in dependent base classes</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="214"> <td><a href="https://cplusplus.github.io/CWG/issues/214.html">214</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>CD1</td> <td>Partial ordering of function templates is underspecified</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="215"> <td><a href="https://cplusplus.github.io/CWG/issues/215.html">215</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>CD1</td> <td>Template parameters are not allowed in <I>nested-name-specifier</I>s</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="216"> <td><a href="https://cplusplus.github.io/CWG/issues/216.html">216</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD1</td> <td>Linkage of nameless class-scope enumeration types</td> <td class="none" align="center">No</td> </tr> <tr id="217"> <td><a href="https://cplusplus.github.io/CWG/issues/217.html">217</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>TC1</td> <td>Default arguments for non-template member functions of class templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="218"> <td><a href="https://cplusplus.github.io/CWG/issues/218.html">218</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>CD1</td> <td>Specification of Koenig lookup</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="219"> <td><a href="https://cplusplus.github.io/CWG/issues/219.html">219</a></td> + <td>[<a href="https://wg21.link/except.terminate">except.terminate</a>]</td> <td>NAD</td> <td>Cannot defend against destructors that throw exceptions</td> <td class="na" align="center">N/A</td> </tr> <tr id="220"> <td><a href="https://cplusplus.github.io/CWG/issues/220.html">220</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.deallocation">basic.stc.dynamic.deallocation</a>]</td> <td>CD1</td> <td>All deallocation functions should be required not to throw</td> <td class="na" align="center">N/A</td> </tr> <tr id="221"> <td><a href="https://cplusplus.github.io/CWG/issues/221.html">221</a></td> + <td>[<a href="https://wg21.link/over.assign">over.assign</a>]</td> <td>CD1</td> <td>Must compound assignment operators be member functions?</td> <td class="full" align="center">Clang 3.6</td> </tr> <tr id="222"> <td><a href="https://cplusplus.github.io/CWG/issues/222.html">222</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>CD1</td> <td>Sequence points and lvalue-returning operators</td> <td class="full" align="center">Duplicate of <a href="#637">637</a></td> </tr> <tr id="223"> <td><a href="https://cplusplus.github.io/CWG/issues/223.html">223</a></td> + <td>[<a href="https://wg21.link/depr">depr</a>]</td> <td>CD3</td> <td>The meaning of deprecation</td> <td class="na" align="center">N/A</td> </tr> <tr id="224"> <td><a href="https://cplusplus.github.io/CWG/issues/224.html">224</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>CD1</td> <td>Definition of dependent names</td> <td class="full" align="center">Clang 16</td> </tr> <tr id="225"> <td><a href="https://cplusplus.github.io/CWG/issues/225.html">225</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>NAD</td> <td>Koenig lookup and fundamental types</td> <td class="full" align="center">Yes</td> </tr> <tr id="226"> <td><a href="https://cplusplus.github.io/CWG/issues/226.html">226</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>CD1</td> <td>Default template arguments for function templates</td> <td class="none" align="center">No</td> </tr> <tr id="227"> <td><a href="https://cplusplus.github.io/CWG/issues/227.html">227</a></td> + <td>[<a href="https://wg21.link/stmt.select">stmt.select</a>]</td> <td>TC1</td> <td>How many scopes in an <TT>if</TT> statement?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="228"> <td><a href="https://cplusplus.github.io/CWG/issues/228.html">228</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>CD1</td> <td>Use of <TT>template</TT> keyword with non-member templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="229"> <td><a href="https://cplusplus.github.io/CWG/issues/229.html">229</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial">temp.spec.partial</a>]</td> <td>NAD</td> <td>Partial specialization of function templates</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="230"> <td><a href="https://cplusplus.github.io/CWG/issues/230.html">230</a></td> + <td>[<a href="https://wg21.link/class.abstract">class.abstract</a>]</td> <td>NAD</td> <td>Calls to pure virtual functions</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="231"> <td><a href="https://cplusplus.github.io/CWG/issues/231.html">231</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>NAD</td> <td>Visibility of names after <I>using-directive</I>s</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="232"> <td><a href="https://cplusplus.github.io/CWG/issues/232.html">232</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>NAD</td> <td>Is indirection through a null pointer undefined behavior?</td> <td class="none" align="center">Duplicate of <a href="#2823">2823</a></td> </tr> <tr id="233"> <td><a href="https://cplusplus.github.io/CWG/issues/233.html">233</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD7</td> <td>References vs pointers in UDC overload resolution</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="234"> <td><a href="https://cplusplus.github.io/CWG/issues/234.html">234</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>NAD</td> <td>Reuse of base class subobjects</td> <td class="na" align="center">N/A</td> </tr> <tr id="235"> <td><a href="https://cplusplus.github.io/CWG/issues/235.html">235</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>TC1</td> <td>Assignment vs initialization</td> <td class="na" align="center">N/A</td> </tr> <tr id="236"> <td><a href="https://cplusplus.github.io/CWG/issues/236.html">236</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td>Explicit temporaries and integral constant expressions</td> <td class="full" align="center">Clang 3.2</td> </tr> <tr id="237"> <td><a href="https://cplusplus.github.io/CWG/issues/237.html">237</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>CD1</td> <td>Explicit instantiation and base class members</td> <td class="full" align="center">Duplicate of <a href="#470">470</a></td> </tr> <tr id="238"> <td><a href="https://cplusplus.github.io/CWG/issues/238.html">238</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>CD4</td> <td>Precision and accuracy constraints on floating point</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="239"> <td><a href="https://cplusplus.github.io/CWG/issues/239.html">239</a></td> + <td>[<a href="https://wg21.link/over.call.func">over.call.func</a>]</td> <td>CD1</td> <td>Footnote 116 and Koenig lookup</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="240"> <td><a href="https://cplusplus.github.io/CWG/issues/240.html">240</a></td> + <td>[<a href="https://wg21.link/conv.lval">conv.lval</a>]</td> <td>CD3</td> <td>Uninitialized values and undefined behavior</td> <td class="full" align="center">Duplicate of <a href="#616">616</a></td> </tr> <tr id="241"> <td><a href="https://cplusplus.github.io/CWG/issues/241.html">241</a></td> + <td>[<a href="https://wg21.link/temp.arg.explicit">temp.arg.explicit</a>]</td> <td>TC1</td> <td>Error in example in 14.8.1</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="242"> <td><a href="https://cplusplus.github.io/CWG/issues/242.html">242</a></td> + <td>[<a href="https://wg21.link/expr.cast">expr.cast</a>]</td> <td>CD4</td> <td>Interpretation of old-style casts</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="243"> <td><a href="https://cplusplus.github.io/CWG/issues/243.html">243</a></td> + <td>[<a href="https://wg21.link/over.ics.user">over.ics.user</a>]</td> <td>NAD</td> <td>Weighting of conversion functions in direct-initialization</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="244"> <td><a href="https://cplusplus.github.io/CWG/issues/244.html">244</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD1</td> <td>Destructor lookup</td> <td class="full" align="center">Clang 11</td> </tr> <tr id="245"> <td><a href="https://cplusplus.github.io/CWG/issues/245.html">245</a></td> + <td>[<a href="https://wg21.link/basic.lookup.elab">basic.lookup.elab</a>]</td> <td>CD1</td> <td>Name lookup in <I>elaborated-type-specifier</I>s</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="246"> <td><a href="https://cplusplus.github.io/CWG/issues/246.html">246</a></td> + <td>[<a href="https://wg21.link/temp.arg">temp.arg</a>]</td> <td>CD1</td> <td>Jumps in <I>function-try-block</I> handlers</td> <td class="full" align="center">Clang 3.2</td> </tr> <tr id="247"> <td><a href="https://cplusplus.github.io/CWG/issues/247.html">247</a></td> + <td>[<a href="https://wg21.link/over.over">over.over</a>]</td> <td>NAD</td> <td>Pointer-to-member casts and function overload resolution</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="248"> <td><a href="https://cplusplus.github.io/CWG/issues/248.html">248</a></td> + <td>[<a href="https://wg21.link/extendid">extendid</a>]</td> <td>C++11</td> <td>Identifier characters</td> <td class="na" align="center">Superseded by <a href="https://wg21.link/P1949">P1949</a></td> </tr> <tr id="249"> <td><a href="https://cplusplus.github.io/CWG/issues/249.html">249</a></td> + <td>[<a href="https://wg21.link/temp.mem.func">temp.mem.func</a>]</td> <td>TC1</td> <td>What is a member function template?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="250"> <td><a href="https://cplusplus.github.io/CWG/issues/250.html">250</a></td> + <td>[<a href="https://wg21.link/over.over">over.over</a>]</td> <td>TC1</td> <td>Address of function template specialization with non-deduced template arguments</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="251"> <td><a href="https://cplusplus.github.io/CWG/issues/251.html">251</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>open</td> <td>How many signed integer types are there?</td> <td align="center">Not resolved</td> </tr> <tr id="252"> <td><a href="https://cplusplus.github.io/CWG/issues/252.html">252</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD1</td> <td>Looking up deallocation functions in virtual destructors</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="253"> <td><a href="https://cplusplus.github.io/CWG/issues/253.html">253</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>C++17</td> <td>Why must empty or fully-initialized const objects be initialized?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="254"> <td><a href="https://cplusplus.github.io/CWG/issues/254.html">254</a></td> + <td>[<a href="https://wg21.link/basic.lookup.elab">basic.lookup.elab</a>]</td> <td>CD1</td> <td>Definitional problems with <I>elaborated-type-specifier</I>s</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="255"> <td><a href="https://cplusplus.github.io/CWG/issues/255.html">255</a></td> + <td>[<a href="https://wg21.link/class.free">class.free</a>]</td> <td>CD6</td> <td>Placement deallocation functions and lookup ambiguity</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="256"> <td><a href="https://cplusplus.github.io/CWG/issues/256.html">256</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD1</td> <td>Overflow in size calculations</td> <td class="unknown" align="center">Duplicate of <a href="#624">624</a></td> </tr> <tr id="257"> <td><a href="https://cplusplus.github.io/CWG/issues/257.html">257</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>CD2</td> <td>Abstract base constructors and virtual base initialization</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="258"> <td><a href="https://cplusplus.github.io/CWG/issues/258.html">258</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD1</td> <td><I>using-declaration</I>s and cv-qualifiers</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="259"> <td><a href="https://cplusplus.github.io/CWG/issues/259.html">259</a></td> + <td>[<a href="https://wg21.link/temp.spec">temp.spec</a>]</td> <td>CD1</td> <td>Restrictions on explicit specialization and instantiation</td> <td class="full" align="center">Clang 4</td> </tr> <tr class="open" id="260"> <td><a href="https://cplusplus.github.io/CWG/issues/260.html">260</a></td> + <td>[<a href="https://wg21.link/over.built">over.built</a>]</td> <td>open</td> <td>User-defined conversions and built-in <TT>operator=</TT></td> <td align="center">Not resolved</td> </tr> <tr id="261"> <td><a href="https://cplusplus.github.io/CWG/issues/261.html">261</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD1</td> <td>When is a deallocation function "used?"</td> <td class="none" align="center">No</td> </tr> <tr id="262"> <td><a href="https://cplusplus.github.io/CWG/issues/262.html">262</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD1</td> <td>Default arguments and ellipsis</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="263"> <td><a href="https://cplusplus.github.io/CWG/issues/263.html">263</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>CD1</td> <td>Can a constructor be declared a friend?</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr class="open" id="264"> <td><a href="https://cplusplus.github.io/CWG/issues/264.html">264</a></td> + <td>[<a href="https://wg21.link/temp.arg.explicit">temp.arg.explicit</a>]</td> <td>open</td> <td>Unusable template constructors and conversion functions</td> <td align="center">Not resolved</td> </tr> <tr id="265"> <td><a href="https://cplusplus.github.io/CWG/issues/265.html">265</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>dup</td> <td>Destructors, exceptions, and deallocation</td> <td class="unknown" align="center">Duplicate of <a href="#353">353</a></td> </tr> <tr id="266"> <td><a href="https://cplusplus.github.io/CWG/issues/266.html">266</a></td> + <td>[<a href="https://wg21.link/gram">gram</a>]</td> <td>NAD</td> <td>No grammar sentence symbol</td> <td class="na" align="center">N/A</td> </tr> <tr class="open" id="267"> <td><a href="https://cplusplus.github.io/CWG/issues/267.html">267</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>open</td> <td>Alignment requirement for <I>new-expression</I>s</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="268"> <td><a href="https://cplusplus.github.io/CWG/issues/268.html">268</a></td> + <td>[<a href="https://wg21.link/cpp.rescan">cpp.rescan</a>]</td> <td>open</td> <td>Macro name suppression in rescanned replacement text</td> <td align="center">Not resolved</td> </tr> <tr id="269"> <td><a href="https://cplusplus.github.io/CWG/issues/269.html">269</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>NAD</td> - <td>Order of initialization of multiply-defined static data members -of class templates</td> + <td>Order of initialization of multiply-defined static data members of class templates</td> <td class="na" align="center">N/A</td> </tr> <tr id="270"> <td><a href="https://cplusplus.github.io/CWG/issues/270.html">270</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>CD1</td> <td>Order of initialization of static data members of class templates</td> <td class="na" align="center">N/A</td> </tr> <tr id="271"> <td><a href="https://cplusplus.github.io/CWG/issues/271.html">271</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD6</td> <td>Explicit instantiation and template argument deduction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="272"> <td><a href="https://cplusplus.github.io/CWG/issues/272.html">272</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD1</td> <td>Explicit destructor invocation and <I>qualified-id</I>s</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="273"> <td><a href="https://cplusplus.github.io/CWG/issues/273.html">273</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD1</td> <td>POD classes and <TT>operator&()</TT></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="274"> <td><a href="https://cplusplus.github.io/CWG/issues/274.html">274</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD1</td> <td>Cv-qualification and char-alias access to out-of-lifetime objects</td> <td class="na" align="center">N/A</td> </tr> <tr id="275"> <td><a href="https://cplusplus.github.io/CWG/issues/275.html">275</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>CD1</td> <td>Explicit instantiation/specialization and <I>using-directive</I>s</td> <td class="none" align="center">No</td> </tr> <tr id="276"> <td><a href="https://cplusplus.github.io/CWG/issues/276.html">276</a></td> + <td>[<a href="https://wg21.link/stmt.jump">stmt.jump</a>]</td> <td>CD1</td> <td>Order of destruction of parameters and temporaries</td> <td class="na" align="center">N/A</td> </tr> <tr id="277"> <td><a href="https://cplusplus.github.io/CWG/issues/277.html">277</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD1</td> <td>Zero-initialization of pointers</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="278"> <td><a href="https://cplusplus.github.io/CWG/issues/278.html">278</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>NAD</td> <td>External linkage and nameless entities</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="279"> <td><a href="https://cplusplus.github.io/CWG/issues/279.html">279</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD6</td> <td>Correspondence of "names for linkage purposes"</td> <td class="none" align="center">No</td> </tr> <tr id="280"> <td><a href="https://cplusplus.github.io/CWG/issues/280.html">280</a></td> + <td>[<a href="https://wg21.link/over.call.object">over.call.object</a>]</td> <td>CD1</td> <td>Access and surrogate call functions</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="281"> <td><a href="https://cplusplus.github.io/CWG/issues/281.html">281</a></td> + <td>[<a href="https://wg21.link/dcl.fct.spec">dcl.fct.spec</a>]</td> <td>CD1</td> <td><TT>inline</TT> specifier in <TT>friend</TT> declarations</td> <td class="none" align="center">No</td> </tr> <tr class="open" id="282"> <td><a href="https://cplusplus.github.io/CWG/issues/282.html">282</a></td> + <td>[<a href="https://wg21.link/expr.typeid">expr.typeid</a>]</td> <td>open</td> <td>Namespace for <TT>extended_type_info</TT></td> <td align="center">Not resolved</td> </tr> <tr id="283"> <td><a href="https://cplusplus.github.io/CWG/issues/283.html">283</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>CD1</td> <td>Template <I>type-parameter</I>s are not syntactically <I>type-name</I>s</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="284"> <td><a href="https://cplusplus.github.io/CWG/issues/284.html">284</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD1</td> <td><I>qualified-id</I>s in class declarations</td> <td class="none" align="center">No</td> </tr> <tr id="285"> <td><a href="https://cplusplus.github.io/CWG/issues/285.html">285</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>NAD</td> <td>Identifying a function template being specialized</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="286"> <td><a href="https://cplusplus.github.io/CWG/issues/286.html">286</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial">temp.spec.partial</a>]</td> <td>CD1</td> <td>Incorrect example in partial specialization</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr class="open" id="287"> <td><a href="https://cplusplus.github.io/CWG/issues/287.html">287</a></td> + <td>[<a href="https://wg21.link/temp.point">temp.point</a>]</td> <td>drafting</td> <td>Order dependencies in template instantiation</td> <td align="center">Not resolved</td> </tr> <tr id="288"> <td><a href="https://cplusplus.github.io/CWG/issues/288.html">288</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>CD1</td> <td>Misuse of "static type" in describing pointers</td> <td class="na" align="center">N/A</td> </tr> <tr id="289"> <td><a href="https://cplusplus.github.io/CWG/issues/289.html">289</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD1</td> <td>Incomplete list of contexts requiring a complete type</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="290"> <td><a href="https://cplusplus.github.io/CWG/issues/290.html">290</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>NAD</td> <td>Should memcpy be allowed into a POD with a const member?</td> <td class="na" align="center">N/A</td> </tr> <tr id="291"> <td><a href="https://cplusplus.github.io/CWG/issues/291.html">291</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD1</td> <td>Overload resolution needed when binding reference to class rvalue</td> <td class="full" align="center">Duplicate of <a href="#391">391</a></td> </tr> <tr id="292"> <td><a href="https://cplusplus.github.io/CWG/issues/292.html">292</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD3</td> <td>Deallocation on exception in <TT>new</TT> before arguments evaluated</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr class="open" id="293"> <td><a href="https://cplusplus.github.io/CWG/issues/293.html">293</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>open</td> <td>Syntax of explicit instantiation/specialization too permissive</td> <td align="center">Not resolved</td> </tr> <tr id="294"> <td><a href="https://cplusplus.github.io/CWG/issues/294.html">294</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>NAD</td> <td>Can <TT>static_cast</TT> drop exception specifications?</td> <td class="none" align="center">No</td> </tr> <tr id="295"> <td><a href="https://cplusplus.github.io/CWG/issues/295.html">295</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD1</td> <td>cv-qualifiers on function types</td> <td class="full" align="center">Clang 3.7</td> </tr> <tr id="296"> <td><a href="https://cplusplus.github.io/CWG/issues/296.html">296</a></td> + <td>[<a href="https://wg21.link/class.conv.fct">class.conv.fct</a>]</td> <td>CD1</td> <td>Can conversion functions be static?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="297"> <td><a href="https://cplusplus.github.io/CWG/issues/297.html">297</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>NAD</td> <td>Which template does an explicit specialization specialize?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="298"> <td><a href="https://cplusplus.github.io/CWG/issues/298.html">298</a></td> + <td>[<a href="https://wg21.link/class.qual">class.qual</a>]</td> <td>CD1</td> <td><TT>T::x</TT> when <TT>T</TT> is cv-qualified</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="299"> <td><a href="https://cplusplus.github.io/CWG/issues/299.html">299</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD1</td> <td>Conversion on array bound expression in <TT>new</TT></td> <td class="full" align="center">Clang 2.8 (C++11 onwards)</td> </tr> <tr id="300"> <td><a href="https://cplusplus.github.io/CWG/issues/300.html">300</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>CD1</td> <td>References to functions in template argument deduction</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="301"> <td><a href="https://cplusplus.github.io/CWG/issues/301.html">301</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>CD1</td> <td>Syntax for <I>template-name</I></td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="302"> <td><a href="https://cplusplus.github.io/CWG/issues/302.html">302</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD1</td> <td>Value-initialization and generation of default constructor</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="303"> <td><a href="https://cplusplus.github.io/CWG/issues/303.html">303</a></td> + <td>[<a href="https://wg21.link/conv.prom">conv.prom</a>]</td> <td>NAD</td> <td>Integral promotions on bit-fields</td> <td class="na" align="center">N/A</td> </tr> <tr id="304"> <td><a href="https://cplusplus.github.io/CWG/issues/304.html">304</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>TC1</td> <td>Value-initialization of a reference</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="305"> <td><a href="https://cplusplus.github.io/CWG/issues/305.html">305</a></td> + <td>[<a href="https://wg21.link/basic.lookup.classref">basic.lookup.classref</a>]</td> <td>CD1</td> <td>Name lookup in destructor call</td> <td class="none" align="center">No</td> </tr> <tr id="306"> <td><a href="https://cplusplus.github.io/CWG/issues/306.html">306</a></td> + <td>[<a href="https://wg21.link/class.member.lookup">class.member.lookup</a>]</td> <td>CD1</td> <td>Ambiguity by class name injection</td> <td class="none" align="center">Duplicate of <a href="#39">39</a></td> </tr> <tr id="307"> <td><a href="https://cplusplus.github.io/CWG/issues/307.html">307</a></td> + <td>[<a href="https://wg21.link/class.cdtor">class.cdtor</a>]</td> <td>NAD</td> <td>Initialization of a virtual base class subobject</td> <td class="na" align="center">N/A</td> </tr> <tr id="308"> <td><a href="https://cplusplus.github.io/CWG/issues/308.html">308</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>NAD</td> <td>Catching exceptions with ambiguous base classes</td> <td class="full" align="center">Clang 3.7</td> </tr> <tr id="309"> <td><a href="https://cplusplus.github.io/CWG/issues/309.html">309</a></td> + <td>[<a href="https://wg21.link/basic.pre">basic.pre</a>]</td> <td>CD1</td> <td>Linkage of entities whose names are not simply identifiers, in introduction</td> <td class="full" align="center">Duplicate of <a href="#485">485</a></td> </tr> <tr class="open" id="310"> <td><a href="https://cplusplus.github.io/CWG/issues/310.html">310</a></td> + <td>[<a href="https://wg21.link/temp.over.link">temp.over.link</a>]</td> <td>open</td> <td>Can function templates differing only in parameter cv-qualifiers be overloaded?</td> <td align="center">Not resolved</td> </tr> <tr id="311"> <td><a href="https://cplusplus.github.io/CWG/issues/311.html">311</a></td> + <td>[<a href="https://wg21.link/namespace.def">namespace.def</a>]</td> <td>NAD</td> <td>Using qualified name to reopen nested namespace</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="312"> <td><a href="https://cplusplus.github.io/CWG/issues/312.html">312</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.deallocation">basic.stc.dynamic.deallocation</a>]</td> <td>CD3</td> <td>“use” of invalid pointer value not defined</td> <td class="full" align="center">Duplicate of <a href="#616">616</a></td> </tr> <tr id="313"> <td><a href="https://cplusplus.github.io/CWG/issues/313.html">313</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>dup</td> <td>Class with single conversion function to integral as array size in <TT>new</TT></td> <td class="full" align="center">Duplicate of <a href="#299">299</a> (C++11 onwards)</td> </tr> <tr id="314"> <td><a href="https://cplusplus.github.io/CWG/issues/314.html">314</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>C++17</td> <td><TT>template</TT> in base class specifier</td> <td class="none" align="center">No</td> </tr> <tr id="315"> <td><a href="https://cplusplus.github.io/CWG/issues/315.html">315</a></td> + <td>[<a href="https://wg21.link/class.static.mfct">class.static.mfct</a>]</td> <td>NAD</td> <td>Is call of static member function through null pointer undefined?</td> <td class="na" align="center">N/A</td> </tr> <tr id="316"> <td><a href="https://cplusplus.github.io/CWG/issues/316.html">316</a></td> + <td>[<a href="https://wg21.link/temp.local">temp.local</a>]</td> <td>NAD</td> <td>Injected-class-name of template used as template template parameter</td> <td class="full-superseded" align="center">Superseded by <a href="#1004">1004</a></td> </tr> <tr id="317"> <td><a href="https://cplusplus.github.io/CWG/issues/317.html">317</a></td> + <td>[<a href="https://wg21.link/dcl.fct.spec">dcl.fct.spec</a>]</td> <td>CD1</td> <td>Can a function be declared inline after it has been called?</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="318"> <td><a href="https://cplusplus.github.io/CWG/issues/318.html">318</a></td> + <td>[<a href="https://wg21.link/class.qual">class.qual</a>]</td> <td>CD1</td> <td><TT>struct A::A</TT> should not name the constructor of <TT>A</TT></td> <td class="full-superseded" align="center">Superseded by <a href="#1310">1310</a></td> </tr> <tr id="319"> <td><a href="https://cplusplus.github.io/CWG/issues/319.html">319</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD1</td> <td>Use of names without linkage in declaring entities with linkage</td> <td class="none" align="center">No</td> </tr> <tr id="320"> <td><a href="https://cplusplus.github.io/CWG/issues/320.html">320</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD1</td> <td>Question on copy constructor elision example</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="321"> <td><a href="https://cplusplus.github.io/CWG/issues/321.html">321</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>dup</td> <td>Associated classes and namespaces for argument-dependent lookup</td> <td class="full" align="center">Duplicate of <a href="#557">557</a></td> </tr> <tr id="322"> <td><a href="https://cplusplus.github.io/CWG/issues/322.html">322</a></td> + <td>[<a href="https://wg21.link/temp.deduct.conv">temp.deduct.conv</a>]</td> <td>CD1</td> <td>Deduction of reference conversions</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="323"> <td><a href="https://cplusplus.github.io/CWG/issues/323.html">323</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>CD1</td> <td>Where must <TT>export</TT> appear?</td> <td class="full-superseded" align="center">Superseded by <a href="#820">820</a></td> </tr> <tr id="324"> <td><a href="https://cplusplus.github.io/CWG/issues/324.html">324</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>CD1</td> <td>Can "<TT>&</TT>" be applied to assignment to bit-field?</td> <td class="full" align="center">Clang 3.6</td> </tr> <tr class="open" id="325"> <td><a href="https://cplusplus.github.io/CWG/issues/325.html">325</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>open</td> <td>When are default arguments parsed?</td> <td align="center">Not resolved</td> </tr> <tr id="326"> <td><a href="https://cplusplus.github.io/CWG/issues/326.html">326</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>CD1</td> <td>Wording for definition of trivial constructor</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="327"> <td><a href="https://cplusplus.github.io/CWG/issues/327.html">327</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD1</td> <td>Use of "structure" without definition</td> <td class="na" align="center">Duplicate of <a href="#538">538</a></td> </tr> <tr id="328"> <td><a href="https://cplusplus.github.io/CWG/issues/328.html">328</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD1</td> <td>Missing requirement that class member types be complete</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="329"> <td><a href="https://cplusplus.github.io/CWG/issues/329.html">329</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>CD1</td> <td>Evaluation of friends of templates</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="330"> <td><a href="https://cplusplus.github.io/CWG/issues/330.html">330</a></td> + <td>[<a href="https://wg21.link/conv.qual">conv.qual</a>]</td> <td>CD4</td> <td>Qualification conversions and pointers to arrays of pointers</td> <td class="full" align="center">Clang 7</td> </tr> <tr id="331"> <td><a href="https://cplusplus.github.io/CWG/issues/331.html">331</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>CD1</td> <td>Allowed copy constructor signatures</td> <td class="full" align="center">Clang 11</td> </tr> <tr id="332"> <td><a href="https://cplusplus.github.io/CWG/issues/332.html">332</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD3</td> <td>cv-qualified <TT>void</TT> parameter types</td> <td class="full" align="center">Duplicate of <a href="#577">577</a></td> </tr> <tr id="333"> <td><a href="https://cplusplus.github.io/CWG/issues/333.html">333</a></td> + <td>[<a href="https://wg21.link/dcl.ambig.res">dcl.ambig.res</a>]</td> <td>NAD</td> <td>Ambiguous use of "declaration" in disambiguation section</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="334"> <td><a href="https://cplusplus.github.io/CWG/issues/334.html">334</a></td> + <td>[<a href="https://wg21.link/temp.dep.expr">temp.dep.expr</a>]</td> <td>NAD</td> <td>Is a comma-expression dependent if its first operand is?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="335"> <td><a href="https://cplusplus.github.io/CWG/issues/335.html">335</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>CD1</td> <td>Allowing <TT>export</TT> on template members of nontemplate classes</td> <td class="full-superseded" align="center">Superseded by <a href="#820">820</a></td> </tr> <tr id="336"> <td><a href="https://cplusplus.github.io/CWG/issues/336.html">336</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>CD1</td> <td>Explicit specialization examples are still incorrect</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="337"> <td><a href="https://cplusplus.github.io/CWG/issues/337.html">337</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD1</td> <td>Attempt to create array of abtract type should cause deduction to fail</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="338"> <td><a href="https://cplusplus.github.io/CWG/issues/338.html">338</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD6</td> <td>Enumerator name with linkage used as class name in other translation unit</td> <td class="partial" align="center">Duplicate of <a href="#1884">1884</a></td> </tr> <tr id="339"> <td><a href="https://cplusplus.github.io/CWG/issues/339.html">339</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD1</td> <td>Overload resolution in operand of <TT>sizeof</TT> in constant expression</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="340"> <td><a href="https://cplusplus.github.io/CWG/issues/340.html">340</a></td> + <td>[<a href="https://wg21.link/dcl.ambig.res">dcl.ambig.res</a>]</td> <td>NAD</td> <td>Unclear wording in disambiguation section</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="341"> <td><a href="https://cplusplus.github.io/CWG/issues/341.html">341</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>C++11</td> <td><TT>extern "C"</TT> namespace member function versus global variable</td> <td class="unknown-superseded" align="center">Superseded by <a href="#1708">1708</a></td> </tr> <tr id="342"> <td><a href="https://cplusplus.github.io/CWG/issues/342.html">342</a></td> + <td>[<a href="https://wg21.link/expr.unary">expr.unary</a>]</td> <td>CD3</td> <td>Terminology: "indirection" versus "dereference"</td> <td class="na" align="center">N/A</td> </tr> <tr id="343"> <td><a href="https://cplusplus.github.io/CWG/issues/343.html">343</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>C++17</td> <td>Make <TT>template</TT> optional in contexts that require a type</td> <td class="none" align="center">No</td> </tr> <tr id="344"> <td><a href="https://cplusplus.github.io/CWG/issues/344.html">344</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD3</td> <td>Naming destructors</td> <td class="unknown" align="center">Duplicate of <a href="#1435">1435</a></td> </tr> <tr id="345"> <td><a href="https://cplusplus.github.io/CWG/issues/345.html">345</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>CD1</td> <td>Misleading comment on example in templates chapter</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="346"> <td><a href="https://cplusplus.github.io/CWG/issues/346.html">346</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>NAD</td> <td>Typo in 15.4</td> <td class="na" align="center">N/A</td> </tr> <tr id="347"> <td><a href="https://cplusplus.github.io/CWG/issues/347.html">347</a></td> + <td>[<a href="https://wg21.link/class.nest">class.nest</a>]</td> <td>NAD</td> <td>Use of derived class name in defining base class nested class</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="348"> <td><a href="https://cplusplus.github.io/CWG/issues/348.html">348</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.deallocation">basic.stc.dynamic.deallocation</a>]</td> <td>CD1</td> <td><TT>delete</TT> and user-written deallocation functions</td> <td class="na" align="center">N/A</td> </tr> <tr id="349"> <td><a href="https://cplusplus.github.io/CWG/issues/349.html">349</a></td> + <td>[<a href="https://wg21.link/temp.deduct.conv">temp.deduct.conv</a>]</td> <td>CD1</td> <td>Template argument deduction for conversion functions and qualification conversions</td> <td class="none" align="center">No</td> </tr> <tr class="open" id="350"> <td><a href="https://cplusplus.github.io/CWG/issues/350.html">350</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>open</td> <td><TT>signed char</TT> underlying representation for objects</td> <td align="center">Not resolved</td> </tr> <tr id="351"> <td><a href="https://cplusplus.github.io/CWG/issues/351.html">351</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>CD1</td> <td>Sequence point error: unspecified or undefined?</td> <td class="na" align="center">N/A</td> </tr> <tr id="352"> <td><a href="https://cplusplus.github.io/CWG/issues/352.html">352</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>CD1</td> <td>Nondeduced contexts</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="353"> <td><a href="https://cplusplus.github.io/CWG/issues/353.html">353</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>CD1</td> <td>Is deallocation routine called if destructor throws exception in delete?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="354"> <td><a href="https://cplusplus.github.io/CWG/issues/354.html">354</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>CD1</td> <td>Null as nontype template argument</td> <td class="full" align="center">Clang 3.1 (C++11 onwards)</td> </tr> <tr id="355"> <td><a href="https://cplusplus.github.io/CWG/issues/355.html">355</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>C++11</td> <td>Global-scope <TT>::</TT> in <I>nested-name-specifier</I></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="356"> <td><a href="https://cplusplus.github.io/CWG/issues/356.html">356</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>NAD</td> <td>Wording of behavior of generated copy constructor for scalar members</td> <td class="na" align="center">N/A</td> </tr> <tr id="357"> <td><a href="https://cplusplus.github.io/CWG/issues/357.html">357</a></td> + <td>[<a href="https://wg21.link/intro.defs">intro.defs</a>]</td> <td>CD1</td> <td>Definition of signature should include name</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="358"> <td><a href="https://cplusplus.github.io/CWG/issues/358.html">358</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>NAD</td> <td>Namespaces and extern "C"</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="359"> <td><a href="https://cplusplus.github.io/CWG/issues/359.html">359</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>NAD</td> <td>Type definition in anonymous union</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr id="360"> <td><a href="https://cplusplus.github.io/CWG/issues/360.html">360</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>CD6</td> <td>Using-declaration that reduces access</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr class="open" id="361"> <td><a href="https://cplusplus.github.io/CWG/issues/361.html">361</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>open</td> <td>Forward reference to default argument</td> <td align="center">Not resolved</td> </tr> <tr id="362"> <td><a href="https://cplusplus.github.io/CWG/issues/362.html">362</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>CD1</td> <td>Order of initialization in instantiation units</td> <td class="na" align="center">N/A</td> </tr> <tr id="363"> <td><a href="https://cplusplus.github.io/CWG/issues/363.html">363</a></td> + <td>[<a href="https://wg21.link/class.expl.init">class.expl.init</a>]</td> <td>NAD</td> <td>Initialization of class from self</td> <td class="na" align="center">N/A</td> </tr> <tr id="364"> <td><a href="https://cplusplus.github.io/CWG/issues/364.html">364</a></td> + <td>[<a href="https://wg21.link/over.call.func">over.call.func</a>]</td> <td>CD1</td> <td>Calling overloaded function with static in set, with no object</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="365"> <td><a href="https://cplusplus.github.io/CWG/issues/365.html">365</a></td> + <td>[<a href="https://wg21.link/basic.stc">basic.stc</a>]</td> <td>open</td> <td>Storage duration and temporaries</td> <td align="center">Not resolved</td> </tr> <tr id="366"> <td><a href="https://cplusplus.github.io/CWG/issues/366.html">366</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD1</td> <td>String literal allowed in integral constant expression?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="367"> <td><a href="https://cplusplus.github.io/CWG/issues/367.html">367</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD1</td> <td><TT>throw</TT> operator allowed in constant expression?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="368"> <td><a href="https://cplusplus.github.io/CWG/issues/368.html">368</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD1</td> <td>Uses of non-type parameters that should cause deduction to fail</td> <td class="full" align="center">Clang 3.6</td> </tr> <tr class="open" id="369"> <td><a href="https://cplusplus.github.io/CWG/issues/369.html">369</a></td> + <td>[<a href="https://wg21.link/lex.pptoken">lex.pptoken</a>]</td> <td>open</td> <td>Are <TT>new</TT>/<TT>delete</TT> identifiers or <I>preprocessing-op-or-punc</I>?</td> <td align="center">Not resolved</td> </tr> <tr id="370"> <td><a href="https://cplusplus.github.io/CWG/issues/370.html">370</a></td> + <td>[<a href="https://wg21.link/cpp.include">cpp.include</a>]</td> <td>CD1</td> <td>Can <TT>#include <...></TT> form be used other than for standard C++ headers?</td> <td class="na" align="center">N/A</td> </tr> <tr class="open" id="371"> <td><a href="https://cplusplus.github.io/CWG/issues/371.html">371</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>open</td> <td>Interleaving of constructor calls</td> <td align="center">Not resolved</td> </tr> <tr id="372"> <td><a href="https://cplusplus.github.io/CWG/issues/372.html">372</a></td> + <td>[<a href="https://wg21.link/temp.arg">temp.arg</a>]</td> <td>CD1</td> <td>Is access granted by base class specifiers available in following base class specifiers?</td> <td class="none" align="center">No</td> </tr> <tr id="373"> <td><a href="https://cplusplus.github.io/CWG/issues/373.html">373</a></td> + <td>[<a href="https://wg21.link/basic.lookup.udir">basic.lookup.udir</a>]</td> <td>C++11</td> <td>Lookup on namespace qualified name in using-directive</td> <td class="full" align="center">Clang 5</td> </tr> <tr id="374"> <td><a href="https://cplusplus.github.io/CWG/issues/374.html">374</a></td> + <td>[<a href="https://wg21.link/dcl.meaning">dcl.meaning</a>]</td> <td>CD2</td> <td>Can explicit specialization outside namespace use qualified name?</td> <td class="full" align="center">Clang 7</td> </tr> <tr id="375"> <td><a href="https://cplusplus.github.io/CWG/issues/375.html">375</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>dup</td> <td>Confusing example on lookup with <TT>typename</TT></td> <td class="full" align="center">Duplicate of <a href="#345">345</a></td> </tr> <tr id="376"> <td><a href="https://cplusplus.github.io/CWG/issues/376.html">376</a></td> + <td>[<a href="https://wg21.link/dcl.fct.spec">dcl.fct.spec</a>]</td> <td>NAD</td> <td>Class "definition" versus class "declaration"</td> <td class="na" align="center">N/A</td> </tr> <tr id="377"> <td><a href="https://cplusplus.github.io/CWG/issues/377.html">377</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD1</td> <td>Enum whose enumerators will not fit in any integral type</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="378"> <td><a href="https://cplusplus.github.io/CWG/issues/378.html">378</a></td> + <td>[<a href="https://wg21.link/stmt.jump">stmt.jump</a>]</td> <td>CD1</td> <td>Wording that says temporaries are declared</td> <td class="na" align="center">Duplicate of <a href="#276">276</a></td> </tr> <tr id="379"> <td><a href="https://cplusplus.github.io/CWG/issues/379.html">379</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD1</td> <td>Change "class declaration" to "class definition"</td> <td class="na" align="center">N/A</td> </tr> <tr class="open" id="380"> <td><a href="https://cplusplus.github.io/CWG/issues/380.html">380</a></td> + <td>[<a href="https://wg21.link/class.member.lookup">class.member.lookup</a>]</td> <td>open</td> <td>Definition of "ambiguous base class" missing</td> <td align="center">Not resolved</td> </tr> <tr id="381"> <td><a href="https://cplusplus.github.io/CWG/issues/381.html">381</a></td> + <td>[<a href="https://wg21.link/basic.lookup.classref">basic.lookup.classref</a>]</td> <td>CD1</td> <td>Incorrect example of base class member lookup</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="382"> <td><a href="https://cplusplus.github.io/CWG/issues/382.html">382</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>CD1</td> <td>Allow <TT>typename</TT> outside of templates</td> <td class="full" align="center">Clang 2.7 (C++11 onwards)</td> </tr> <tr id="383"> <td><a href="https://cplusplus.github.io/CWG/issues/383.html">383</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD1</td> <td>Is a class with a declared but not defined destructor a POD?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="384"> <td><a href="https://cplusplus.github.io/CWG/issues/384.html">384</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>NAD</td> <td>Argument-dependent lookup and operator functions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="385"> <td><a href="https://cplusplus.github.io/CWG/issues/385.html">385</a></td> + <td>[<a href="https://wg21.link/class.protected">class.protected</a>]</td> <td>CD1</td> <td>How does protected member check of 11.5 interact with using-declarations?</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="386"> <td><a href="https://cplusplus.github.io/CWG/issues/386.html">386</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD6</td> <td>Friend declaration of name brought in by <I>using-declaration</I></td> <td class="none" align="center">No</td> </tr> <tr id="387"> <td><a href="https://cplusplus.github.io/CWG/issues/387.html">387</a></td> + <td>[<a href="https://wg21.link/temp.inject">temp.inject</a>]</td> <td>CD1</td> <td>Errors in example in 14.6.5</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="388"> <td><a href="https://cplusplus.github.io/CWG/issues/388.html">388</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>CD3</td> <td>Catching base<TT>*&</TT> from a throw of derived<TT>*</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="389"> <td><a href="https://cplusplus.github.io/CWG/issues/389.html">389</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD1</td> <td>Unnamed types in entities with linkage</td> <td class="none" align="center">No</td> </tr> <tr id="390"> <td><a href="https://cplusplus.github.io/CWG/issues/390.html">390</a></td> + <td>[<a href="https://wg21.link/class.abstract">class.abstract</a>]</td> <td>CD1</td> <td>Pure virtual must be defined when implicitly called</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr id="391"> <td><a href="https://cplusplus.github.io/CWG/issues/391.html">391</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD1</td> <td>Require direct binding of short-lived references to rvalues</td> <td class="full" align="center">Clang 2.8 (C++11 onwards)</td> </tr> <tr id="392"> <td><a href="https://cplusplus.github.io/CWG/issues/392.html">392</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD1</td> <td>Use of full expression lvalue before temporary destruction</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="393"> <td><a href="https://cplusplus.github.io/CWG/issues/393.html">393</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD4</td> <td>Pointer to array of unknown bound in template argument list in parameter</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="394"> <td><a href="https://cplusplus.github.io/CWG/issues/394.html">394</a></td> + <td>[<a href="https://wg21.link/cpp.pre">cpp.pre</a>]</td> <td>CD1</td> <td><I>identifier-list</I> is never defined</td> <td class="na" align="center">N/A</td> </tr> <tr id="395"> <td><a href="https://cplusplus.github.io/CWG/issues/395.html">395</a></td> + <td>[<a href="https://wg21.link/class.conv.fct">class.conv.fct</a>]</td> <td>NAD</td> <td>Conversion operator template syntax</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="396"> <td><a href="https://cplusplus.github.io/CWG/issues/396.html">396</a></td> + <td>[<a href="https://wg21.link/dcl.fct.spec">dcl.fct.spec</a>]</td> <td>CD1</td> <td>Misleading note regarding use of <TT>auto</TT> for disambiguation</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="397"> <td><a href="https://cplusplus.github.io/CWG/issues/397.html">397</a></td> + <td>[<a href="https://wg21.link/dcl.fct.spec">dcl.fct.spec</a>]</td> <td>CD1</td> <td>Same address for string literals from default arguments in inline functions?</td> <td class="unknown-superseded" align="center">Superseded by <a href="#1823">1823</a></td> </tr> <tr id="398"> <td><a href="https://cplusplus.github.io/CWG/issues/398.html">398</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD1</td> <td>Ambiguous wording on naming a type in deduction</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="399"> <td><a href="https://cplusplus.github.io/CWG/issues/399.html">399</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD6</td> <td>Destructor lookup redux</td> <td class="full" align="center">Clang 11</td> </tr> <tr id="400"> <td><a href="https://cplusplus.github.io/CWG/issues/400.html">400</a></td> + <td>[<a href="https://wg21.link/namespace.qual">namespace.qual</a>]</td> <td>CD1</td> <td>Using-declarations and the "struct hack"</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="401"> <td><a href="https://cplusplus.github.io/CWG/issues/401.html">401</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>CD1</td> <td>When is access for template parameter default arguments checked?</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr class="open" id="402"> <td><a href="https://cplusplus.github.io/CWG/issues/402.html">402</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>open</td> <td>More on partial ordering of function templates</td> <td align="center">Not resolved</td> </tr> <tr id="403"> <td><a href="https://cplusplus.github.io/CWG/issues/403.html">403</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>CD1</td> <td>Reference to a type as a <I>template-id</I></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="404"> <td><a href="https://cplusplus.github.io/CWG/issues/404.html">404</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD1</td> <td>Unclear reference to construction with non-trivial constructor</td> <td class="na" align="center">N/A</td> </tr> <tr id="405"> <td><a href="https://cplusplus.github.io/CWG/issues/405.html">405</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>CD6</td> <td>Unqualified function name lookup</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="406"> <td><a href="https://cplusplus.github.io/CWG/issues/406.html">406</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>CD1</td> <td>Static data member in class with name for linkage purposes</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="407"> <td><a href="https://cplusplus.github.io/CWG/issues/407.html">407</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>C++11</td> <td>Named class with associated typedef: two names or one?</td> <td class="full" align="center">Clang 3.8</td> </tr> <tr id="408"> <td><a href="https://cplusplus.github.io/CWG/issues/408.html">408</a></td> + <td>[<a href="https://wg21.link/temp.static">temp.static</a>]</td> <td>CD2</td> <td>sizeof applied to unknown-bound array static data member of template</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="409"> <td><a href="https://cplusplus.github.io/CWG/issues/409.html">409</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>CD1</td> <td>Obsolete paragraph missed by changes for issue 224</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="410"> <td><a href="https://cplusplus.github.io/CWG/issues/410.html">410</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>CD1</td> <td>Paragraph missed in changes for issue 166</td> <td class="none" align="center">No</td> </tr> <tr id="411"> <td><a href="https://cplusplus.github.io/CWG/issues/411.html">411</a></td> + <td>[<a href="https://wg21.link/lex.string">lex.string</a>]</td> <td>CD6</td> <td>Use of universal-character-name in character versus string literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="412"> <td><a href="https://cplusplus.github.io/CWG/issues/412.html">412</a></td> + <td>[<a href="https://wg21.link/dcl.fct.spec">dcl.fct.spec</a>]</td> <td>NAD</td> <td>Can a replacement allocation function be inline?</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="413"> <td><a href="https://cplusplus.github.io/CWG/issues/413.html">413</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD1</td> <td>Definition of "empty class"</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="414"> <td><a href="https://cplusplus.github.io/CWG/issues/414.html">414</a></td> + <td>[<a href="https://wg21.link/basic.lookup.classref">basic.lookup.classref</a>]</td> <td>CD1</td> <td>Multiple types found on destructor lookup</td> <td class="none" align="center">Duplicate of <a href="#305">305</a></td> </tr> <tr id="415"> <td><a href="https://cplusplus.github.io/CWG/issues/415.html">415</a></td> + <td>[<a href="https://wg21.link/temp.over">temp.over</a>]</td> <td>CD1</td> <td>Template deduction does not cause instantiation</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="416"> <td><a href="https://cplusplus.github.io/CWG/issues/416.html">416</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>CD1</td> <td>Class must be complete to allow operator lookup?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="417"> <td><a href="https://cplusplus.github.io/CWG/issues/417.html">417</a></td> + <td>[<a href="https://wg21.link/class.name">class.name</a>]</td> <td>CD1</td> <td>Using derived-class qualified name in out-of-class nested class definition</td> <td class="none" align="center">No</td> </tr> <tr id="418"> <td><a href="https://cplusplus.github.io/CWG/issues/418.html">418</a></td> + <td>[<a href="https://wg21.link/over.match.best">over.match.best</a>]</td> <td>CD6</td> <td>Imperfect wording on error on multiple default arguments on a called function</td> <td class="none" align="center">No</td> </tr> <tr class="open" id="419"> <td><a href="https://cplusplus.github.io/CWG/issues/419.html">419</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>open</td> <td>Can cast to virtual base class be done on partially-constructed object?</td> <td align="center">Not resolved</td> </tr> <tr id="420"> <td><a href="https://cplusplus.github.io/CWG/issues/420.html">420</a></td> + <td>[<a href="https://wg21.link/over.ref">over.ref</a>]</td> <td>CD1</td> <td>postfixexpression->scalar_type_dtor() inconsistent</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="421"> <td><a href="https://cplusplus.github.io/CWG/issues/421.html">421</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>CD1</td> <td>Is rvalue.field an rvalue?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="422"> <td><a href="https://cplusplus.github.io/CWG/issues/422.html">422</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>NAD</td> <td>Is a typedef redeclaration allowed with a template type that might be the same?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="423"> <td><a href="https://cplusplus.github.io/CWG/issues/423.html">423</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>NAD</td> <td>Can a conversion be done on the left operand of a compound assignment?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="424"> <td><a href="https://cplusplus.github.io/CWG/issues/424.html">424</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>CD1</td> <td>Wording problem with issue 56 resolution on redeclaring typedefs in class scope</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="425"> <td><a href="https://cplusplus.github.io/CWG/issues/425.html">425</a></td> + <td>[<a href="https://wg21.link/over.built">over.built</a>]</td> <td>CD1</td> <td>Set of candidates for overloaded built-in operator with float operand</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="426"> <td><a href="https://cplusplus.github.io/CWG/issues/426.html">426</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>C++17</td> <td>Identically-named variables, one internally and one externally linked, allowed?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="427"> <td><a href="https://cplusplus.github.io/CWG/issues/427.html">427</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD1</td> <td><TT>static_cast</TT> ambiguity: conversion versus cast to derived</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="428"> <td><a href="https://cplusplus.github.io/CWG/issues/428.html">428</a></td> + <td>[<a href="https://wg21.link/except.throw">except.throw</a>]</td> <td>CD1</td> <td>Mention of expression with reference type</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="429"> <td><a href="https://cplusplus.github.io/CWG/issues/429.html">429</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD1</td> <td>Matching deallocation function chosen based on syntax or signature?</td> <td class="full" align="center">Clang 2.8 (C++11 onwards)</td> </tr> <tr id="430"> <td><a href="https://cplusplus.github.io/CWG/issues/430.html">430</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>CD1</td> <td>Ordering of expression evaluation in initializer list</td> <td class="full" align="center">Clang 2.7 (C++11 onwards)</td> </tr> <tr id="431"> <td><a href="https://cplusplus.github.io/CWG/issues/431.html">431</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>C++11</td> <td>Defect in wording in 14.2</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="432"> <td><a href="https://cplusplus.github.io/CWG/issues/432.html">432</a></td> + <td>[<a href="https://wg21.link/basic.scope.class">basic.scope.class</a>]</td> <td>CD1</td> <td>Is injected class name visible in base class specifier list?</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="433"> <td><a href="https://cplusplus.github.io/CWG/issues/433.html">433</a></td> + <td>[<a href="https://wg21.link/basic.scope.pdecl">basic.scope.pdecl</a>]</td> <td>CD1</td> <td>Do elaborated type specifiers in templates inject into enclosing namespace scope?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="434"> <td><a href="https://cplusplus.github.io/CWG/issues/434.html">434</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>NAD</td> <td>Unclear suppression of standard conversions while binding reference to lvalue</td> <td class="full-superseded" align="center">Superseded by <a href="#2352">2352</a></td> </tr> <tr id="435"> <td><a href="https://cplusplus.github.io/CWG/issues/435.html">435</a></td> + <td>[<a href="https://wg21.link/dcl.pre">dcl.pre</a>]</td> <td>NAD</td> <td>Change "declararation or definition" to "declaration"</td> <td class="na" align="center">N/A</td> </tr> <tr id="436"> <td><a href="https://cplusplus.github.io/CWG/issues/436.html">436</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>CD1</td> <td>Problem in example in 9.6 paragraph 4</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="437"> <td><a href="https://cplusplus.github.io/CWG/issues/437.html">437</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD1</td> <td>Is type of class allowed in member function exception specification?</td> <td class="full-superseded-superseded" align="center">Superseded by <a href="#1308">1308</a></td> </tr> <tr id="438"> <td><a href="https://cplusplus.github.io/CWG/issues/438.html">438</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>CD2</td> <td>Possible flaw in wording for multiple accesses to object between sequence points</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="439"> <td><a href="https://cplusplus.github.io/CWG/issues/439.html">439</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD1</td> <td>Guarantees on casting pointer back to cv-qualified version of original type</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="440"> <td><a href="https://cplusplus.github.io/CWG/issues/440.html">440</a></td> + <td>[<a href="https://wg21.link/temp.arg">temp.arg</a>]</td> <td>NAD</td> <td>Allow implicit pointer-to-member conversion on nontype template argument</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="441"> <td><a href="https://cplusplus.github.io/CWG/issues/441.html">441</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>CD1</td> <td>Ordering of static reference initialization</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="442"> <td><a href="https://cplusplus.github.io/CWG/issues/442.html">442</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>CD1</td> <td>Incorrect use of null pointer constant in description of delete operator</td> <td class="na-superseded" align="center">Superseded by <a href="#348">348</a></td> </tr> <tr id="443"> <td><a href="https://cplusplus.github.io/CWG/issues/443.html">443</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD1</td> <td>Wording nit in description of lifetime of temporaries</td> <td class="na" align="center">N/A</td> </tr> <tr id="444"> <td><a href="https://cplusplus.github.io/CWG/issues/444.html">444</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>NAD</td> <td>Overriding and the generated copy assignment operator</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="445"> <td><a href="https://cplusplus.github.io/CWG/issues/445.html">445</a></td> + <td>[<a href="https://wg21.link/class.friend">class.friend</a>]</td> <td>NAD</td> <td>Wording issue on friend declarations</td> <td class="full" align="center">Clang 3.2</td> </tr> <tr id="446"> <td><a href="https://cplusplus.github.io/CWG/issues/446.html">446</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD1</td> <td>Does an lvalue-to-rvalue conversion on the "?" operator produce a temporary?</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="447"> <td><a href="https://cplusplus.github.io/CWG/issues/447.html">447</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>CD1</td> <td>Is offsetof type-dependent?</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="448"> <td><a href="https://cplusplus.github.io/CWG/issues/448.html">448</a></td> + <td>[<a href="https://wg21.link/temp.local">temp.local</a>]</td> <td>C++11</td> <td>Set of template functions in call with dependent explicit argument</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="449"> <td><a href="https://cplusplus.github.io/CWG/issues/449.html">449</a></td> + <td>[<a href="https://wg21.link/intro.defs">intro.defs</a>]</td> <td>NAD</td> <td>Consistency in use of hyphen with names of "non" entities</td> <td class="na" align="center">N/A</td> </tr> <tr id="450"> <td><a href="https://cplusplus.github.io/CWG/issues/450.html">450</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD1</td> <td>Binding a reference to const to a cv-qualified array rvalue</td> <td class="full" align="center">Clang 3.2</td> </tr> <tr id="451"> <td><a href="https://cplusplus.github.io/CWG/issues/451.html">451</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>CD1</td> <td>Expressions with invalid results and ill-formedness</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="452"> <td><a href="https://cplusplus.github.io/CWG/issues/452.html">452</a></td> + <td>[<a href="https://wg21.link/class.this">class.this</a>]</td> <td>CD1</td> <td>Wording nit on description of <TT>this</TT></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="453"> <td><a href="https://cplusplus.github.io/CWG/issues/453.html">453</a></td> + <td>[<a href="https://wg21.link/dcl.ref">dcl.ref</a>]</td> <td>CD7</td> <td>References may only bind to “valid” objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="454"> <td><a href="https://cplusplus.github.io/CWG/issues/454.html">454</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>CD1</td> <td>When is a definition of a static data member required?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="455"> <td><a href="https://cplusplus.github.io/CWG/issues/455.html">455</a></td> + <td>[<a href="https://wg21.link/over.match.best">over.match.best</a>]</td> <td>NAD</td> <td>Partial ordering and non-deduced arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="456"> <td><a href="https://cplusplus.github.io/CWG/issues/456.html">456</a></td> + <td>[<a href="https://wg21.link/conv.ptr">conv.ptr</a>]</td> <td>NAD</td> <td>Is initialized const int or const bool variable a null pointer constant?</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="457"> <td><a href="https://cplusplus.github.io/CWG/issues/457.html">457</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD1</td> <td>Wording nit on use of const variables in constant expressions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="458"> <td><a href="https://cplusplus.github.io/CWG/issues/458.html">458</a></td> + <td>[<a href="https://wg21.link/temp.local">temp.local</a>]</td> <td>C++11</td> <td>Hiding of member template parameters by other members</td> <td class="full" align="center">Clang 11</td> </tr> <tr id="459"> <td><a href="https://cplusplus.github.io/CWG/issues/459.html">459</a></td> + <td>[<a href="https://wg21.link/temp.local">temp.local</a>]</td> <td>NAD</td> <td>Hiding of template parameters by base class members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="460"> <td><a href="https://cplusplus.github.io/CWG/issues/460.html">460</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD1</td> <td>Can a <I>using-declaration</I> name a namespace?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="461"> <td><a href="https://cplusplus.github.io/CWG/issues/461.html">461</a></td> + <td>[<a href="https://wg21.link/dcl.asm">dcl.asm</a>]</td> <td>NAD</td> <td>Make <TT>asm</TT> conditionally-supported</td> <td class="na" align="center">N/A</td> </tr> <tr id="462"> <td><a href="https://cplusplus.github.io/CWG/issues/462.html">462</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD3</td> <td>Lifetime of temporaries bound to comma expressions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="463"> <td><a href="https://cplusplus.github.io/CWG/issues/463.html">463</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>CD1</td> <td><TT>reinterpret_cast<T*>(0)</TT></td> <td class="na" align="center">N/A</td> </tr> <tr id="464"> <td><a href="https://cplusplus.github.io/CWG/issues/464.html">464</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD1</td> <td>Wording nit on lifetime of temporaries to which references are bound</td> <td class="na" align="center">N/A</td> </tr> <tr id="465"> <td><a href="https://cplusplus.github.io/CWG/issues/465.html">465</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>NAD</td> <td>May constructors of global objects call <TT>exit()</TT>?</td> <td class="na" align="center">N/A</td> </tr> <tr id="466"> <td><a href="https://cplusplus.github.io/CWG/issues/466.html">466</a></td> + <td>[<a href="https://wg21.link/expr.pseudo">expr.pseudo</a>]</td> <td>CD1</td> <td>cv-qualifiers on pseudo-destructor type</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="467"> <td><a href="https://cplusplus.github.io/CWG/issues/467.html">467</a></td> + <td>[<a href="https://wg21.link/stmt.dcl">stmt.dcl</a>]</td> <td>NAD</td> <td>Jump past initialization of local static variable</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="468"> <td><a href="https://cplusplus.github.io/CWG/issues/468.html">468</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>CD1</td> <td>Allow <TT>::template</TT> outside of templates</td> <td class="full" align="center">Clang 2.7 (C++11 onwards)</td> </tr> <tr id="469"> <td><a href="https://cplusplus.github.io/CWG/issues/469.html">469</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>NAD</td> <td>Const template specializations and reference arguments</td> <td class="none" align="center">No</td> </tr> <tr id="470"> <td><a href="https://cplusplus.github.io/CWG/issues/470.html">470</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>CD1</td> <td>Instantiation of members of an explicitly-instantiated class template</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="471"> <td><a href="https://cplusplus.github.io/CWG/issues/471.html">471</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>NAD</td> <td>Conflicting inherited access specifications</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr class="open" id="472"> <td><a href="https://cplusplus.github.io/CWG/issues/472.html">472</a></td> + <td>[<a href="https://wg21.link/class.protected">class.protected</a>]</td> <td>open</td> <td>Casting across protected inheritance</td> <td align="center"> @@ -2887,5528 +3358,6447 @@ of class templates</td> </tr> <tr id="473"> <td><a href="https://cplusplus.github.io/CWG/issues/473.html">473</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>NAD</td> <td>Block-scope declarations of allocator functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="474"> <td><a href="https://cplusplus.github.io/CWG/issues/474.html">474</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD1</td> <td>Block-scope <TT>extern</TT> declarations in namespace members</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="475"> <td><a href="https://cplusplus.github.io/CWG/issues/475.html">475</a></td> + <td>[<a href="https://wg21.link/except.uncaught">except.uncaught</a>]</td> <td>C++11</td> <td>When is <TT>std::uncaught_exception()</TT> true? (take 2)</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="476"> <td><a href="https://cplusplus.github.io/CWG/issues/476.html">476</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD5</td> <td>Determining the buffer size for placement new</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="477"> <td><a href="https://cplusplus.github.io/CWG/issues/477.html">477</a></td> + <td>[<a href="https://wg21.link/dcl.fct.spec">dcl.fct.spec</a>]</td> <td>CD1</td> <td>Can <TT>virtual</TT> appear in a <TT>friend</TT> declaration?</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="478"> <td><a href="https://cplusplus.github.io/CWG/issues/478.html">478</a></td> + <td>[<a href="https://wg21.link/dcl.array">dcl.array</a>]</td> <td>NAD</td> <td>May a function parameter be an array of an abstract class type?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="479"> <td><a href="https://cplusplus.github.io/CWG/issues/479.html">479</a></td> + <td>[<a href="https://wg21.link/except.throw">except.throw</a>]</td> <td>CD1</td> <td>Copy elision in exception handling</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="480"> <td><a href="https://cplusplus.github.io/CWG/issues/480.html">480</a></td> + <td>[<a href="https://wg21.link/conv.mem">conv.mem</a>]</td> <td>CD1</td> <td>Is a base of a virtual base also virtual?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="481"> <td><a href="https://cplusplus.github.io/CWG/issues/481.html">481</a></td> + <td>[<a href="https://wg21.link/basic.scope">basic.scope</a>]</td> <td>CD2</td> <td>Scope of template parameters</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="482"> <td><a href="https://cplusplus.github.io/CWG/issues/482.html">482</a></td> + <td>[<a href="https://wg21.link/dcl.meaning">dcl.meaning</a>]</td> <td>CD3</td> <td>Qualified declarators in redeclarations</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="483"> <td><a href="https://cplusplus.github.io/CWG/issues/483.html">483</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>CD3</td> <td>Normative requirements on integral ranges</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="484"> <td><a href="https://cplusplus.github.io/CWG/issues/484.html">484</a></td> + <td>[<a href="https://wg21.link/class.derived">class.derived</a>]</td> <td>CD1</td> <td>Can a <I>base-specifier</I> name a cv-qualified class type?</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="485"> <td><a href="https://cplusplus.github.io/CWG/issues/485.html">485</a></td> + <td>[<a href="https://wg21.link/basic.pre">basic.pre</a>]</td> <td>CD1</td> <td>What is a “name”?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="486"> <td><a href="https://cplusplus.github.io/CWG/issues/486.html">486</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD1</td> <td>Invalid return types and template argument deduction</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="487"> <td><a href="https://cplusplus.github.io/CWG/issues/487.html">487</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td>Operator overloading in constant expressions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="488"> <td><a href="https://cplusplus.github.io/CWG/issues/488.html">488</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD1</td> <td>Local types, overload resolution, and template argument deduction</td> <td class="full" align="center">Clang 2.9 (C++11 onwards)</td> </tr> <tr id="489"> <td><a href="https://cplusplus.github.io/CWG/issues/489.html">489</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>NAD</td> <td>Must member function templates be instantiated during overload resolution?</td> <td class="na" align="center">N/A</td> </tr> <tr id="490"> <td><a href="https://cplusplus.github.io/CWG/issues/490.html">490</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>CD2</td> <td>Name lookup in friend declarations</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="491"> <td><a href="https://cplusplus.github.io/CWG/issues/491.html">491</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>CD1</td> <td>Initializers for empty-class aggregrate members</td> <td class="full" align="center">Duplicate of <a href="#413">413</a></td> </tr> <tr id="492"> <td><a href="https://cplusplus.github.io/CWG/issues/492.html">492</a></td> + <td>[<a href="https://wg21.link/expr.typeid">expr.typeid</a>]</td> <td>CD1</td> <td><TT>typeid</TT> constness inconsistent with example</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="493"> <td><a href="https://cplusplus.github.io/CWG/issues/493.html">493</a></td> + <td>[<a href="https://wg21.link/temp.deduct.conv">temp.deduct.conv</a>]</td> <td>CD2</td> <td>Type deduction from a <TT>bool</TT> context</td> <td class="unknown" align="center">Duplicate of <a href="#976">976</a></td> </tr> <tr id="494"> <td><a href="https://cplusplus.github.io/CWG/issues/494.html">494</a></td> + <td>[<a href="https://wg21.link/class.access">class.access</a>]</td> <td>CD1</td> <td>Problems with the resolution of issue 45</td> <td class="none" align="center">Duplicate of <a href="#372">372</a></td> </tr> <tr id="495"> <td><a href="https://cplusplus.github.io/CWG/issues/495.html">495</a></td> + <td>[<a href="https://wg21.link/over.match.best">over.match.best</a>]</td> <td>CD2</td> <td>Overload resolution with template and non-template conversion functions</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="496"> <td><a href="https://cplusplus.github.io/CWG/issues/496.html">496</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>CD3</td> <td>Is a volatile-qualified type really a POD?</td> <td class="full-superseded" align="center">Superseded by <a href="#2094">2094</a></td> </tr> <tr id="497"> <td><a href="https://cplusplus.github.io/CWG/issues/497.html">497</a></td> + <td>[<a href="https://wg21.link/expr.mptr.oper">expr.mptr.oper</a>]</td> <td>CD1</td> <td>Missing required initialization in example</td> <td class="unknown-superseded" align="center">Superseded by <a href="#253">253</a></td> </tr> <tr class="open" id="498"> <td><a href="https://cplusplus.github.io/CWG/issues/498.html">498</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>open</td> <td>Storage class specifiers in definitions of class members</td> <td align="center">Not resolved</td> </tr> <tr id="499"> <td><a href="https://cplusplus.github.io/CWG/issues/499.html">499</a></td> + <td>[<a href="https://wg21.link/except.throw">except.throw</a>]</td> <td>CD2</td> <td>Throwing an array of unknown size</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="500"> <td><a href="https://cplusplus.github.io/CWG/issues/500.html">500</a></td> + <td>[<a href="https://wg21.link/class.friend">class.friend</a>]</td> <td>CD1</td> <td>Access in <I>base-specifier</I>s of friend and nested classes</td> <td class="none" align="center">Duplicate of <a href="#372">372</a></td> </tr> <tr id="501"> <td><a href="https://cplusplus.github.io/CWG/issues/501.html">501</a></td> + <td>[<a href="https://wg21.link/class.friend">class.friend</a>]</td> <td>NAD</td> <td>Visibility of friend declarations within the befriending class</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="502"> <td><a href="https://cplusplus.github.io/CWG/issues/502.html">502</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>C++11</td> <td>Dependency of nested enumerations and enumerators</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="503"> <td><a href="https://cplusplus.github.io/CWG/issues/503.html">503</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>open</td> <td>Cv-qualified function types in template argument deduction</td> <td align="center">Not resolved</td> </tr> <tr id="504"> <td><a href="https://cplusplus.github.io/CWG/issues/504.html">504</a></td> + <td>[<a href="https://wg21.link/dcl.ref">dcl.ref</a>]</td> <td>NAD</td> <td>Should use of a variable in its own initializer require a diagnostic?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="505"> <td><a href="https://cplusplus.github.io/CWG/issues/505.html">505</a></td> + <td>[<a href="https://wg21.link/lex.ccon">lex.ccon</a>]</td> <td>CD1</td> <td>Conditionally-supported behavior for unknown character escapes</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="506"> <td><a href="https://cplusplus.github.io/CWG/issues/506.html">506</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD1</td> <td>Conditionally-supported behavior for non-POD objects passed to ellipsis</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="507"> <td><a href="https://cplusplus.github.io/CWG/issues/507.html">507</a></td> + <td>[<a href="https://wg21.link/over.built">over.built</a>]</td> <td>dup</td> <td>Ambiguity assigning class object to built-in type</td> <td class="unknown" align="center">Duplicate of <a href="#260">260</a></td> </tr> <tr id="508"> <td><a href="https://cplusplus.github.io/CWG/issues/508.html">508</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>C++11</td> <td>Non-constructed value-initialized objects</td> <td class="na" align="center">N/A</td> </tr> <tr id="509"> <td><a href="https://cplusplus.github.io/CWG/issues/509.html">509</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD1</td> <td>Dead code in the specification of default initialization</td> <td class="na" align="center">N/A</td> </tr> <tr id="510"> <td><a href="https://cplusplus.github.io/CWG/issues/510.html">510</a></td> + <td>[<a href="https://wg21.link/class.init">class.init</a>]</td> <td>CD1</td> <td>Default initialization of POD classes?</td> <td class="na" align="center">N/A</td> </tr> <tr id="511"> <td><a href="https://cplusplus.github.io/CWG/issues/511.html">511</a></td> + <td>[<a href="https://wg21.link/class.prop">class.prop</a>]</td> <td>NAD</td> <td>POD-structs with template assignment operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="512"> <td><a href="https://cplusplus.github.io/CWG/issues/512.html">512</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>NAD</td> <td>Union members with user-declared non-default constructors</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="513"> <td><a href="https://cplusplus.github.io/CWG/issues/513.html">513</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>CD1</td> <td>Non-class “most-derived” objects</td> <td class="na" align="center">N/A</td> </tr> <tr id="514"> <td><a href="https://cplusplus.github.io/CWG/issues/514.html">514</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>CD1</td> <td>Is the initializer for a namespace member in the scope of the namespace?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="515"> <td><a href="https://cplusplus.github.io/CWG/issues/515.html">515</a></td> + <td>[<a href="https://wg21.link/temp.dep">temp.dep</a>]</td> <td>CD1</td> <td>Non-dependent references to base class members</td> <td class="unknown-superseded" align="center">Superseded by <a href="#1017">1017</a></td> </tr> <tr id="516"> <td><a href="https://cplusplus.github.io/CWG/issues/516.html">516</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>CD1</td> <td>Use of <TT>signed</TT> in bit-field declarations</td> <td class="na" align="center">N/A</td> </tr> <tr id="517"> <td><a href="https://cplusplus.github.io/CWG/issues/517.html">517</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial.general">temp.spec.partial.general</a>]</td> <td>CD1</td> <td>Partial specialization following explicit instantiation</td> <td class="none" align="center">No</td> </tr> <tr id="518"> <td><a href="https://cplusplus.github.io/CWG/issues/518.html">518</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD1</td> <td>Trailing comma following <I>enumerator-list</I></td> <td class="full" align="center">Clang 2.7 (C++11 onwards)</td> </tr> <tr id="519"> <td><a href="https://cplusplus.github.io/CWG/issues/519.html">519</a></td> + <td>[<a href="https://wg21.link/conv.ptr">conv.ptr</a>]</td> <td>CD1</td> <td>Null pointer preservation in <TT>void*</TT> conversions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="520"> <td><a href="https://cplusplus.github.io/CWG/issues/520.html">520</a></td> + <td>[<a href="https://wg21.link/expr.cast">expr.cast</a>]</td> <td>CD1</td> <td>Old-style casts between incomplete class types</td> <td class="na" align="center">N/A</td> </tr> <tr id="521"> <td><a href="https://cplusplus.github.io/CWG/issues/521.html">521</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.allocation">basic.stc.dynamic.allocation</a>]</td> <td>CD1</td> <td>Requirements for exceptions thrown by allocation functions</td> <td class="none" align="center">No</td> </tr> <tr id="522"> <td><a href="https://cplusplus.github.io/CWG/issues/522.html">522</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>CD1</td> <td>Array-to-pointer decay in template argument deduction</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="523"> <td><a href="https://cplusplus.github.io/CWG/issues/523.html">523</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.deallocation">basic.stc.dynamic.deallocation</a>]</td> <td>open</td> <td>Can a one-past-the-end pointer be invalidated by deleting an adjacent object?</td> <td align="center">Not resolved</td> </tr> <tr id="524"> <td><a href="https://cplusplus.github.io/CWG/issues/524.html">524</a></td> + <td>[<a href="https://wg21.link/temp.dep">temp.dep</a>]</td> <td>CD1</td> <td>Can function-notation calls to operator functions be dependent?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="525"> <td><a href="https://cplusplus.github.io/CWG/issues/525.html">525</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>CD1</td> <td>Missing <TT>*</TT> in example</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="526"> <td><a href="https://cplusplus.github.io/CWG/issues/526.html">526</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>CD1</td> <td>Confusing aspects in the specification of non-deduced contexts</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="527"> <td><a href="https://cplusplus.github.io/CWG/issues/527.html">527</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD2</td> <td>Problems with linkage of types</td> <td class="na" align="center">N/A</td> </tr> <tr id="528"> <td><a href="https://cplusplus.github.io/CWG/issues/528.html">528</a></td> + <td>[<a href="https://wg21.link/expr.typeid">expr.typeid</a>]</td> <td>NAD</td> <td>Why are incomplete class types not allowed with <TT>typeid</TT>?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="529"> <td><a href="https://cplusplus.github.io/CWG/issues/529.html">529</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>open</td> <td>Use of <TT>template<></TT> with “explicitly-specialized” class templates</td> <td align="center">Not resolved</td> </tr> <tr id="530"> <td><a href="https://cplusplus.github.io/CWG/issues/530.html">530</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD1</td> <td>Nontype template arguments in constant expressions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="531"> <td><a href="https://cplusplus.github.io/CWG/issues/531.html">531</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>C++11</td> <td>Defining members of explicit specializations</td> <td class="partial" align="center">Partial</td> </tr> <tr id="532"> <td><a href="https://cplusplus.github.io/CWG/issues/532.html">532</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>C++11</td> <td>Member/nonmember operator template partial ordering</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="533"> <td><a href="https://cplusplus.github.io/CWG/issues/533.html">533</a></td> + <td>[<a href="https://wg21.link/cpp.include">cpp.include</a>]</td> <td>NAD</td> <td>Special treatment for C-style header names</td> <td class="na" align="center">N/A</td> </tr> <tr id="534"> <td><a href="https://cplusplus.github.io/CWG/issues/534.html">534</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>CD1</td> <td><I>template-name</I>s and <I>operator-function-id</I>s</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="535"> <td><a href="https://cplusplus.github.io/CWG/issues/535.html">535</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD3</td> <td>Copy construction without a copy constructor</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="536"> <td><a href="https://cplusplus.github.io/CWG/issues/536.html">536</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>CD6</td> <td>Problems in the description of <I>id-expression</I>s</td> <td class="na" align="center">N/A</td> </tr> <tr id="537"> <td><a href="https://cplusplus.github.io/CWG/issues/537.html">537</a></td> + <td>[<a href="https://wg21.link/intro.defs">intro.defs</a>]</td> <td>CD1</td> <td>Definition of “signature”</td> <td class="na" align="center">N/A</td> </tr> <tr id="538"> <td><a href="https://cplusplus.github.io/CWG/issues/538.html">538</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD1</td> - <td>Definition and usage -of <I>structure</I>, <I>POD-struct</I>, <I>POD-union</I>, -and <I>POD class</I></td> + <td>Definition and usage of <I>structure</I>, <I>POD-struct</I>, <I>POD-union</I>, and <I>POD class</I></td> <td class="na" align="center">N/A</td> </tr> <tr id="539"> <td><a href="https://cplusplus.github.io/CWG/issues/539.html">539</a></td> + <td>[<a href="https://wg21.link/dcl.type">dcl.type</a>]</td> <td>CD3</td> <td>Constraints on <I>type-specifier-seq</I></td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="540"> <td><a href="https://cplusplus.github.io/CWG/issues/540.html">540</a></td> + <td>[<a href="https://wg21.link/namespace.def">namespace.def</a>]</td> <td>CD1</td> <td>Propagation of cv-qualifiers in reference-to-reference collapse</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="541"> <td><a href="https://cplusplus.github.io/CWG/issues/541.html">541</a></td> + <td>[<a href="https://wg21.link/temp.dep.expr">temp.dep.expr</a>]</td> <td>CD2</td> <td>Dependent function types</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="542"> <td><a href="https://cplusplus.github.io/CWG/issues/542.html">542</a></td> + <td>[<a href="https://wg21.link/class.init">class.init</a>]</td> <td>CD2</td> <td>Value initialization of arrays of POD-structs</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="543"> <td><a href="https://cplusplus.github.io/CWG/issues/543.html">543</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD1</td> <td>Value initialization and default constructors</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="544"> <td><a href="https://cplusplus.github.io/CWG/issues/544.html">544</a></td> + <td>[<a href="https://wg21.link/temp.dep">temp.dep</a>]</td> <td>NAD</td> <td>Base class lookup in explicit specialization</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="545"> <td><a href="https://cplusplus.github.io/CWG/issues/545.html">545</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>open</td> <td>User-defined conversions and built-in operator overload resolution</td> <td align="center">Not resolved</td> </tr> <tr id="546"> <td><a href="https://cplusplus.github.io/CWG/issues/546.html">546</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>C++11</td> <td>Explicit instantiation of class template members</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="547"> <td><a href="https://cplusplus.github.io/CWG/issues/547.html">547</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>C++11</td> <td>Partial specialization on member function types</td> <td class="full" align="center">Clang 3.2</td> </tr> <tr id="548"> <td><a href="https://cplusplus.github.io/CWG/issues/548.html">548</a></td> + <td>[<a href="https://wg21.link/dcl.meaning">dcl.meaning</a>]</td> <td>dup</td> <td><I>qualified-id</I>s in declarations</td> <td class="full" align="center">Duplicate of <a href="#482">482</a></td> </tr> <tr class="open" id="549"> <td><a href="https://cplusplus.github.io/CWG/issues/549.html">549</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial.match">temp.spec.partial.match</a>]</td> <td>drafting</td> <td>Non-deducible parameters in partial specializations</td> <td align="center">Not resolved</td> </tr> <tr id="550"> <td><a href="https://cplusplus.github.io/CWG/issues/550.html">550</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>dup</td> <td>Pointer to array of unknown bound in parameter declarations</td> <td class="full" align="center">Duplicate of <a href="#393">393</a></td> </tr> <tr id="551"> <td><a href="https://cplusplus.github.io/CWG/issues/551.html">551</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>CD1</td> <td>When is <TT>inline</TT> permitted in an explicit instantiation?</td> <td class="full" align="center">Clang 2.7 (C++11 onwards)</td> </tr> <tr id="552"> <td><a href="https://cplusplus.github.io/CWG/issues/552.html">552</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>NAD</td> <td>Use of <TT>typename</TT> in the type in a non-type <I>parameter-declaration</I></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="553"> <td><a href="https://cplusplus.github.io/CWG/issues/553.html">553</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>NAD</td> <td>Problems with friend allocation and deallocation functions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="554"> <td><a href="https://cplusplus.github.io/CWG/issues/554.html">554</a></td> + <td>[<a href="https://wg21.link/basic.scope">basic.scope</a>]</td> <td>CD6</td> <td>Definition of “declarative region” and “scope”</td> <td class="na" align="center">N/A</td> </tr> <tr id="555"> <td><a href="https://cplusplus.github.io/CWG/issues/555.html">555</a></td> + <td>[<a href="https://wg21.link/basic.lookup">basic.lookup</a>]</td> <td>CD5</td> <td>Pseudo-destructor name lookup</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="556"> <td><a href="https://cplusplus.github.io/CWG/issues/556.html">556</a></td> + <td>[<a href="https://wg21.link/expr.assign">expr.assign</a>]</td> <td>CD2</td> <td>Conflicting requirements for acceptable aliasing</td> <td class="na" align="center">N/A</td> </tr> <tr id="557"> <td><a href="https://cplusplus.github.io/CWG/issues/557.html">557</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>CD1</td> <td>Does argument-dependent lookup cause template instantiation?</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="558"> <td><a href="https://cplusplus.github.io/CWG/issues/558.html">558</a></td> + <td>[<a href="https://wg21.link/lex.charset">lex.charset</a>]</td> <td>CD1</td> <td>Excluded characters in universal character names</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="559"> <td><a href="https://cplusplus.github.io/CWG/issues/559.html">559</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>CD1</td> <td>Editing error in issue 382 resolution</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="560"> <td><a href="https://cplusplus.github.io/CWG/issues/560.html">560</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>NAD</td> <td>Use of the <TT>typename</TT> keyword in return types</td> <td class="full" align="center">Clang 16</td> </tr> <tr id="561"> <td><a href="https://cplusplus.github.io/CWG/issues/561.html">561</a></td> + <td>[<a href="https://wg21.link/temp.dep.candidate">temp.dep.candidate</a>]</td> <td>CD2</td> <td>Internal linkage functions in dependent name lookup</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="562"> <td><a href="https://cplusplus.github.io/CWG/issues/562.html">562</a></td> + <td>[<a href="https://wg21.link/class.qual">class.qual</a>]</td> <td>CD6</td> <td><I>qualified-id</I>s in non-expression contexts</td> <td class="na" align="center">N/A</td> </tr> <tr id="563"> <td><a href="https://cplusplus.github.io/CWG/issues/563.html">563</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>CD6</td> <td>Linkage specification for objects</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr id="564"> <td><a href="https://cplusplus.github.io/CWG/issues/564.html">564</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>CD2</td> <td>Agreement of language linkage or <I>linkage-specification</I>s?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="565"> <td><a href="https://cplusplus.github.io/CWG/issues/565.html">565</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD3</td> <td>Conflict rules for <I>using-declaration</I>s naming function templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="566"> <td><a href="https://cplusplus.github.io/CWG/issues/566.html">566</a></td> + <td>[<a href="https://wg21.link/conv.fpint">conv.fpint</a>]</td> <td>NAD</td> <td>Conversion of negative floating point values to integer type</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="567"> <td><a href="https://cplusplus.github.io/CWG/issues/567.html">567</a></td> + <td>[<a href="https://wg21.link/expr.add">expr.add</a>]</td> <td>NAD</td> <td>Can <TT>size_t</TT> and <TT>ptrdiff_t</TT> be larger than <TT>long</TT>?</td> <td class="na" align="center">N/A</td> </tr> <tr id="568"> <td><a href="https://cplusplus.github.io/CWG/issues/568.html">568</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD1</td> <td>Definition of POD is too strict</td> <td class="full" align="center">Clang 3.0 (C++11 onwards)</td> </tr> <tr id="569"> <td><a href="https://cplusplus.github.io/CWG/issues/569.html">569</a></td> + <td>[<a href="https://wg21.link/dcl.pre">dcl.pre</a>]</td> <td>CD2</td> <td>Spurious semicolons at namespace scope should be allowed</td> <td class="full" align="center">Clang 2.7 (C++11 onwards)</td> </tr> <tr id="570"> <td><a href="https://cplusplus.github.io/CWG/issues/570.html">570</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD2</td> <td>Are references subject to the ODR?</td> <td class="na" align="center">Duplicate of <a href="#633">633</a></td> </tr> <tr id="571"> <td><a href="https://cplusplus.github.io/CWG/issues/571.html">571</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD2</td> <td>References declared <TT>const</TT></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="572"> <td><a href="https://cplusplus.github.io/CWG/issues/572.html">572</a></td> + <td>[<a href="https://wg21.link/conv">conv</a>]</td> <td>C++11</td> <td>Standard conversions for non-built-in types</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="573"> <td><a href="https://cplusplus.github.io/CWG/issues/573.html">573</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>C++11</td> <td>Conversions between function pointers and <TT>void*</TT></td> <td class="none" align="center">No</td> </tr> <tr id="574"> <td><a href="https://cplusplus.github.io/CWG/issues/574.html">574</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>NAD</td> <td>Definition of “copy assignment operator”</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="575"> <td><a href="https://cplusplus.github.io/CWG/issues/575.html">575</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>C++11</td> <td>Criteria for deduction failure</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="576"> <td><a href="https://cplusplus.github.io/CWG/issues/576.html">576</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>CD2</td> <td>Typedefs in function definitions</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="577"> <td><a href="https://cplusplus.github.io/CWG/issues/577.html">577</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD3</td> <td><TT>void</TT> in an empty parameter list</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="578"> <td><a href="https://cplusplus.github.io/CWG/issues/578.html">578</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>CD6</td> <td>Phase 1 replacement of characters with <I>universal-character-name</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="579"> <td><a href="https://cplusplus.github.io/CWG/issues/579.html">579</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>open</td> <td>What is a “nested” <TT>></TT> or <TT>>></TT>?</td> <td align="center">Not resolved</td> </tr> <tr id="580"> <td><a href="https://cplusplus.github.io/CWG/issues/580.html">580</a></td> + <td>[<a href="https://wg21.link/class.access">class.access</a>]</td> <td>C++11</td> <td>Access in <I>template-parameter</I>s of member and friend definitions</td> <td class="partial" align="center">Partial</td> </tr> <tr id="581"> <td><a href="https://cplusplus.github.io/CWG/issues/581.html">581</a></td> + <td>[<a href="https://wg21.link/temp.arg.explicit">temp.arg.explicit</a>]</td> <td>CD5</td> <td>Can a templated constructor be explicitly instantiated or specialized?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="582"> <td><a href="https://cplusplus.github.io/CWG/issues/582.html">582</a></td> + <td>[<a href="https://wg21.link/temp.mem">temp.mem</a>]</td> <td>CD1</td> <td>Template conversion functions</td> <td class="na" align="center">N/A</td> </tr> <tr id="583"> <td><a href="https://cplusplus.github.io/CWG/issues/583.html">583</a></td> + <td>[<a href="https://wg21.link/expr.rel">expr.rel</a>]</td> <td>CD3</td> <td>Relational pointer comparisons against the null pointer constant</td> <td class="full" align="center">Clang 4</td> </tr> <tr id="584"> <td><a href="https://cplusplus.github.io/CWG/issues/584.html">584</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>NAD</td> <td>Unions and aliasing</td> <td class="na" align="center">N/A</td> </tr> <tr id="585"> <td><a href="https://cplusplus.github.io/CWG/issues/585.html">585</a></td> + <td>[<a href="https://wg21.link/class.friend">class.friend</a>]</td> <td>NAD</td> <td>Friend template template parameters</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="586"> <td><a href="https://cplusplus.github.io/CWG/issues/586.html">586</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>NAD</td> <td>Default <I>template-argument</I>s and template argument deduction</td> <td class="na" align="center">N/A</td> </tr> <tr id="587"> <td><a href="https://cplusplus.github.io/CWG/issues/587.html">587</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD2</td> <td>Lvalue operands of a conditional expression differing only in cv-qualification</td> <td class="full" align="center">Clang 3.2</td> </tr> <tr id="588"> <td><a href="https://cplusplus.github.io/CWG/issues/588.html">588</a></td> + <td>[<a href="https://wg21.link/temp.dep">temp.dep</a>]</td> <td>CD2</td> <td>Searching dependent bases of classes local to function templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="589"> <td><a href="https://cplusplus.github.io/CWG/issues/589.html">589</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD2</td> <td>Direct binding of class and array rvalues in reference initialization</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="590"> <td><a href="https://cplusplus.github.io/CWG/issues/590.html">590</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>C++11</td> <td>Nested classes and the “current instantiation”</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="591"> <td><a href="https://cplusplus.github.io/CWG/issues/591.html">591</a></td> + <td>[<a href="https://wg21.link/temp.dep">temp.dep</a>]</td> <td>CD4</td> <td>When a dependent base class is the current instantiation</td> <td class="full" align="center">Clang 20</td> </tr> <tr id="592"> <td><a href="https://cplusplus.github.io/CWG/issues/592.html">592</a></td> + <td>[<a href="https://wg21.link/except.ctor">except.ctor</a>]</td> <td>CD1</td> <td>Exceptions during construction of local static objects</td> <td class="na" align="center">N/A</td> </tr> <tr id="593"> <td><a href="https://cplusplus.github.io/CWG/issues/593.html">593</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>NAD</td> <td>Falling off the end of a destructor's <I>function-try-block</I> handler</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="594"> <td><a href="https://cplusplus.github.io/CWG/issues/594.html">594</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD1</td> <td>Coordinating issues 119 and 404 with delegating constructors</td> <td class="na" align="center">N/A</td> </tr> <tr id="595"> <td><a href="https://cplusplus.github.io/CWG/issues/595.html">595</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>dup</td> <td>Exception specifications in templates instantiated from class bodies</td> <td class="full" align="center">Duplicate of <a href="#1330">1330</a></td> </tr> <tr id="596"> <td><a href="https://cplusplus.github.io/CWG/issues/596.html">596</a></td> + <td>[<a href="https://wg21.link/except.unexpected">except.unexpected</a>]</td> <td>NAD</td> <td>Replacing an exception object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="597"> <td><a href="https://cplusplus.github.io/CWG/issues/597.html">597</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD3</td> <td>Conversions applied to out-of-lifetime non-POD lvalues</td> <td class="na" align="center">N/A</td> </tr> <tr id="598"> <td><a href="https://cplusplus.github.io/CWG/issues/598.html">598</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>CD2</td> <td>Associated namespaces of overloaded functions and function templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="599"> <td><a href="https://cplusplus.github.io/CWG/issues/599.html">599</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>CD2</td> <td>Deleting a null function pointer</td> <td class="partial" align="center">Partial</td> </tr> <tr id="600"> <td><a href="https://cplusplus.github.io/CWG/issues/600.html">600</a></td> + <td>[<a href="https://wg21.link/class.access">class.access</a>]</td> <td>CD6</td> <td>Does access control apply to members or to names?</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="601"> <td><a href="https://cplusplus.github.io/CWG/issues/601.html">601</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>CD2</td> <td>Type of literals in preprocessing expressions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="602"> <td><a href="https://cplusplus.github.io/CWG/issues/602.html">602</a></td> + <td>[<a href="https://wg21.link/temp.local">temp.local</a>]</td> <td>C++11</td> <td>When is the injected-class-name of a class template a template?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="603"> <td><a href="https://cplusplus.github.io/CWG/issues/603.html">603</a></td> + <td>[<a href="https://wg21.link/temp.type">temp.type</a>]</td> <td>CD1</td> <td>Type equivalence and unsigned overflow</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="604"> <td><a href="https://cplusplus.github.io/CWG/issues/604.html">604</a></td> + <td>[<a href="https://wg21.link/over.match.ctor">over.match.ctor</a>]</td> <td>CD2</td> <td>Argument list for overload resolution in copy-initialization</td> <td class="na" align="center">N/A</td> </tr> <tr id="605"> <td><a href="https://cplusplus.github.io/CWG/issues/605.html">605</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>C++11</td> <td>Linkage of explicit specializations</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="606"> <td><a href="https://cplusplus.github.io/CWG/issues/606.html">606</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>CD1</td> <td>Template argument deduction for rvalue references</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="607"> <td><a href="https://cplusplus.github.io/CWG/issues/607.html">607</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>CD6</td> <td>Lookup of <I>mem-initializer-id</I>s</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="608"> <td><a href="https://cplusplus.github.io/CWG/issues/608.html">608</a></td> + <td>[<a href="https://wg21.link/class.virtual">class.virtual</a>]</td> <td>CD2</td> <td>Determining the final overrider of a virtual function</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="609"> <td><a href="https://cplusplus.github.io/CWG/issues/609.html">609</a></td> + <td>[<a href="https://wg21.link/dcl.type.cv">dcl.type.cv</a>]</td> <td>CD4</td> <td>What is a “top-level” cv-qualifier?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="610"> <td><a href="https://cplusplus.github.io/CWG/issues/610.html">610</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>NAD</td> <td>Computing the negative of <TT>0U</TT></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="611"> <td><a href="https://cplusplus.github.io/CWG/issues/611.html">611</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD2</td> <td>Zero-initializing references</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="612"> <td><a href="https://cplusplus.github.io/CWG/issues/612.html">612</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>CD2</td> <td>Requirements on a conforming implementation</td> <td class="na" align="center">N/A</td> </tr> <tr id="613"> <td><a href="https://cplusplus.github.io/CWG/issues/613.html">613</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD1</td> <td>Unevaluated uses of non-static class members</td> <td class="full" align="center">Clang 3.1 (C++11 onwards)</td> </tr> <tr id="614"> <td><a href="https://cplusplus.github.io/CWG/issues/614.html">614</a></td> + <td>[<a href="https://wg21.link/expr.mul">expr.mul</a>]</td> <td>CD1</td> <td>Results of integer <TT>/</TT> and <TT>%</TT></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="615"> <td><a href="https://cplusplus.github.io/CWG/issues/615.html">615</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>C++11</td> <td>Incorrect description of variables that can be initialized</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="616"> <td><a href="https://cplusplus.github.io/CWG/issues/616.html">616</a></td> + <td>[<a href="https://wg21.link/intro.defs">intro.defs</a>]</td> <td>CD3</td> <td>Definition of “indeterminate value”</td> <td class="full" align="center">Clang 4</td> </tr> <tr id="617"> <td><a href="https://cplusplus.github.io/CWG/issues/617.html">617</a></td> + <td>[<a href="https://wg21.link/conv.lval">conv.lval</a>]</td> <td>NAD</td> <td>Lvalue-to-rvalue conversions of uninitialized <TT>char</TT> objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="618"> <td><a href="https://cplusplus.github.io/CWG/issues/618.html">618</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>CD2</td> <td>Casts in preprocessor conditional expressions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="619"> <td><a href="https://cplusplus.github.io/CWG/issues/619.html">619</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>C++11</td> <td>Completeness of array types</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="620"> <td><a href="https://cplusplus.github.io/CWG/issues/620.html">620</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD1</td> <td>Declaration order in layout-compatible POD structs</td> <td class="full" align="center">Duplicate of <a href="#568">568</a></td> </tr> <tr id="621"> <td><a href="https://cplusplus.github.io/CWG/issues/621.html">621</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>C++11</td> <td>Template argument deduction from function return types</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="622"> <td><a href="https://cplusplus.github.io/CWG/issues/622.html">622</a></td> + <td>[<a href="https://wg21.link/expr.rel">expr.rel</a>]</td> <td>NAD</td> <td>Relational comparisons of arbitrary pointers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="623"> <td><a href="https://cplusplus.github.io/CWG/issues/623.html">623</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.deallocation">basic.stc.dynamic.deallocation</a>]</td> <td>CD3</td> <td>Use of pointers to deallocated storage</td> <td class="na" align="center">N/A</td> </tr> <tr id="624"> <td><a href="https://cplusplus.github.io/CWG/issues/624.html">624</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD1</td> <td>Overflow in calculating size of allocation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="625"> <td><a href="https://cplusplus.github.io/CWG/issues/625.html">625</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD2</td> <td>Use of <TT>auto</TT> as a <I>template-argument</I></td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="626"> <td><a href="https://cplusplus.github.io/CWG/issues/626.html">626</a></td> + <td>[<a href="https://wg21.link/cpp.stringize">cpp.stringize</a>]</td> <td>CD2</td> <td>Preprocessor string literals</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="627"> <td><a href="https://cplusplus.github.io/CWG/issues/627.html">627</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>NAD</td> <td>Values behaving as types</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="628"> <td><a href="https://cplusplus.github.io/CWG/issues/628.html">628</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD2</td> <td>The values of an enumeration with no enumerator</td> <td class="na" align="center">N/A</td> </tr> <tr id="629"> <td><a href="https://cplusplus.github.io/CWG/issues/629.html">629</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD1</td> <td><TT>auto</TT> parsing ambiguity</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="630"> <td><a href="https://cplusplus.github.io/CWG/issues/630.html">630</a></td> + <td>[<a href="https://wg21.link/lex.charset">lex.charset</a>]</td> <td>CD2</td> <td>Equality of narrow and wide character values in the basic character set</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="631"> <td><a href="https://cplusplus.github.io/CWG/issues/631.html">631</a></td> + <td>[<a href="https://wg21.link/stmt.if">stmt.if</a>]</td> <td>CD3</td> <td>Jumping into a “then” clause</td> <td class="na" align="center">N/A</td> </tr> <tr id="632"> <td><a href="https://cplusplus.github.io/CWG/issues/632.html">632</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>CD1</td> <td>Brace-enclosed initializer for scalar member of aggregate</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="633"> <td><a href="https://cplusplus.github.io/CWG/issues/633.html">633</a></td> + <td>[<a href="https://wg21.link/basic.pre">basic.pre</a>]</td> <td>CD2</td> <td>Specifications for variables that should also apply to references</td> <td class="na" align="center">N/A</td> </tr> <tr id="634"> <td><a href="https://cplusplus.github.io/CWG/issues/634.html">634</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD1</td> <td>Conditionally-supported behavior for non-POD objects passed to ellipsis redux</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="635"> <td><a href="https://cplusplus.github.io/CWG/issues/635.html">635</a></td> + <td>[<a href="https://wg21.link/class.qual">class.qual</a>]</td> <td>NAD</td> <td>Names of constructors and destructors of templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="636"> <td><a href="https://cplusplus.github.io/CWG/issues/636.html">636</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>CD4</td> <td>Dynamic type of objects and aliasing</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="637"> <td><a href="https://cplusplus.github.io/CWG/issues/637.html">637</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>CD1</td> <td>Sequencing rules and example disagree</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="638"> <td><a href="https://cplusplus.github.io/CWG/issues/638.html">638</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>CD2</td> <td>Explicit specialization and friendship</td> <td class="none" align="center">No</td> </tr> <tr id="639"> <td><a href="https://cplusplus.github.io/CWG/issues/639.html">639</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>CD1</td> <td>What makes side effects “different” from one another?</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr id="640"> <td><a href="https://cplusplus.github.io/CWG/issues/640.html">640</a></td> + <td>[<a href="https://wg21.link/basic.start.dynamic">basic.start.dynamic</a>]</td> <td>NAD</td> <td>Accessing destroyed local objects of static storage duration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="641"> <td><a href="https://cplusplus.github.io/CWG/issues/641.html">641</a></td> + <td>[<a href="https://wg21.link/over.match.viable">over.match.viable</a>]</td> <td>CD2</td> <td>Overload resolution and conversion-to-same-type operators</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="642"> <td><a href="https://cplusplus.github.io/CWG/issues/642.html">642</a></td> + <td>[<a href="https://wg21.link/basic.scope.block">basic.scope.block</a>]</td> <td>CD2</td> <td>Definition and use of “block scope” and “local scope”</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="643"> <td><a href="https://cplusplus.github.io/CWG/issues/643.html">643</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>NAD</td> <td>Use of <TT>decltype</TT> in a class <I>member-specification</I></td> <td class="full" align="center">Clang 3.2</td> </tr> <tr id="644"> <td><a href="https://cplusplus.github.io/CWG/issues/644.html">644</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>CD1</td> <td>Should a trivial class type be a literal type?</td> <td class="partial" align="center">Partial</td> </tr> <tr id="645"> <td><a href="https://cplusplus.github.io/CWG/issues/645.html">645</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD2</td> <td>Are bit-field and non-bit-field members layout compatible?</td> <td class="na" align="center">N/A</td> </tr> <tr id="646"> <td><a href="https://cplusplus.github.io/CWG/issues/646.html">646</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>NAD</td> <td>Can a class with a constexpr copy constructor be a literal type?</td> <td class="unknown-superseded" align="center">Superseded by <a href="#981">981</a></td> </tr> <tr id="647"> <td><a href="https://cplusplus.github.io/CWG/issues/647.html">647</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD1</td> <td>Non-constexpr instances of constexpr constructor templates</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="648"> <td><a href="https://cplusplus.github.io/CWG/issues/648.html">648</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD1</td> <td>Constant expressions in constexpr initializers</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="649"> <td><a href="https://cplusplus.github.io/CWG/issues/649.html">649</a></td> + <td>[<a href="https://wg21.link/basic.align">basic.align</a>]</td> <td>CD1</td> <td>Optionally ill-formed extended alignment requests</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="650"> <td><a href="https://cplusplus.github.io/CWG/issues/650.html">650</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD2</td> <td>Order of destruction for temporaries bound to the returned value of a function</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="651"> <td><a href="https://cplusplus.github.io/CWG/issues/651.html">651</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>CD1</td> <td>Problems in <TT>decltype</TT> specification and examples</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="652"> <td><a href="https://cplusplus.github.io/CWG/issues/652.html">652</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD2</td> <td>Compile-time evaluation of floating-point expressions</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="653"> <td><a href="https://cplusplus.github.io/CWG/issues/653.html">653</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>CD2</td> <td>Copy assignment of unions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="654"> <td><a href="https://cplusplus.github.io/CWG/issues/654.html">654</a></td> + <td>[<a href="https://wg21.link/conv.ptr">conv.ptr</a>]</td> <td>CD1</td> <td>Conversions to and from <TT>nullptr_t</TT></td> <td class="full-superseded" align="center">Superseded by <a href="#1423">1423</a></td> </tr> <tr id="655"> <td><a href="https://cplusplus.github.io/CWG/issues/655.html">655</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>C++11</td> <td>Initialization not specified for forwarding constructors</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="656"> <td><a href="https://cplusplus.github.io/CWG/issues/656.html">656</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD2</td> <td>Direct binding to the result of a conversion operator</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="657"> <td><a href="https://cplusplus.github.io/CWG/issues/657.html">657</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD2</td> <td>Abstract class parameter in synthesized declaration</td> <td class="partial" align="center">Partial</td> </tr> <tr id="658"> <td><a href="https://cplusplus.github.io/CWG/issues/658.html">658</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>CD2</td> <td>Defining <TT>reinterpret_cast</TT> for pointer types</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="659"> <td><a href="https://cplusplus.github.io/CWG/issues/659.html">659</a></td> + <td>[<a href="https://wg21.link/expr.alignof">expr.alignof</a>]</td> <td>CD1</td> <td>Alignment of function types</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="660"> <td><a href="https://cplusplus.github.io/CWG/issues/660.html">660</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD1</td> <td>Unnamed scoped enumerations</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="661"> <td><a href="https://cplusplus.github.io/CWG/issues/661.html">661</a></td> + <td>[<a href="https://wg21.link/expr.rel">expr.rel</a>]</td> <td>CD1</td> <td>Semantics of arithmetic comparisons</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="662"> <td><a href="https://cplusplus.github.io/CWG/issues/662.html">662</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>NAD</td> <td>Forming a pointer to a reference type</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="663"> <td><a href="https://cplusplus.github.io/CWG/issues/663.html">663</a></td> + <td>[<a href="https://wg21.link/extendid">extendid</a>]</td> <td>CD1</td> <td>Valid Cyrillic identifier characters</td> <td class="na" align="center">Superseded by <a href="https://wg21.link/P1949">P1949</a></td> </tr> <tr id="664"> <td><a href="https://cplusplus.github.io/CWG/issues/664.html">664</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD2</td> <td>Direct binding of references to non-class rvalue references</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="665"> <td><a href="https://cplusplus.github.io/CWG/issues/665.html">665</a></td> + <td>[<a href="https://wg21.link/expr.dynamic.cast">expr.dynamic.cast</a>]</td> <td>CD2</td> <td>Problems in the specification of <TT>dynamic_cast</TT></td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="666"> <td><a href="https://cplusplus.github.io/CWG/issues/666.html">666</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>CD1</td> <td>Dependent <I>qualified-id</I>s without the <TT>typename</TT> keyword</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="667"> <td><a href="https://cplusplus.github.io/CWG/issues/667.html">667</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD2</td> <td>Trivial special member functions that cannot be implicitly defined</td> <td class="full" align="center">Clang 8</td> </tr> <tr id="668"> <td><a href="https://cplusplus.github.io/CWG/issues/668.html">668</a></td> + <td>[<a href="https://wg21.link/except.terminate">except.terminate</a>]</td> <td>CD2</td> <td>Throwing an exception from the destructor of a local static object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="669"> <td><a href="https://cplusplus.github.io/CWG/issues/669.html">669</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>NAD</td> <td>Confusing specification of the meaning of <TT>decltype</TT></td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="670"> <td><a href="https://cplusplus.github.io/CWG/issues/670.html">670</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD4</td> <td>Copy initialization via derived-to-base conversion in the second step</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="671"> <td><a href="https://cplusplus.github.io/CWG/issues/671.html">671</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD1</td> <td>Explicit conversion from a scoped enumeration type to integral type</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="672"> <td><a href="https://cplusplus.github.io/CWG/issues/672.html">672</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD2</td> <td>Sequencing of initialization in <I>new-expression</I>s</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="673"> <td><a href="https://cplusplus.github.io/CWG/issues/673.html">673</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>NAD</td> <td>Injection of names from <I>elaborated-type-specifier</I>s in <TT>friend</TT> declarations</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="674"> <td><a href="https://cplusplus.github.io/CWG/issues/674.html">674</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>C++11</td> <td>“matching specialization” for a friend declaration</td> <td class="full" align="center">Clang 8</td> </tr> <tr id="675"> <td><a href="https://cplusplus.github.io/CWG/issues/675.html">675</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>CD3</td> <td>Signedness of bit-field with typedef or template parameter type</td> <td class="unknown" align="center">Duplicate of <a href="#739">739</a></td> </tr> <tr id="676"> <td><a href="https://cplusplus.github.io/CWG/issues/676.html">676</a></td> + <td>[<a href="https://wg21.link/basic.def">basic.def</a>]</td> <td>C++11</td> <td><I>static_assert-declaration</I>s and general requirements for declarations</td> <td class="na" align="center">N/A</td> </tr> <tr id="677"> <td><a href="https://cplusplus.github.io/CWG/issues/677.html">677</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD1</td> <td>Deleted <TT>operator delete</TT> and virtual destructors</td> <td class="none" align="center">No</td> </tr> <tr id="678"> <td><a href="https://cplusplus.github.io/CWG/issues/678.html">678</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>C++11</td> <td>Language linkage of member function parameter types and the ODR</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="679"> <td><a href="https://cplusplus.github.io/CWG/issues/679.html">679</a></td> + <td>[<a href="https://wg21.link/temp.type">temp.type</a>]</td> <td>CD1</td> <td>Equivalence of <I>template-id</I>s and operator function templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="680"> <td><a href="https://cplusplus.github.io/CWG/issues/680.html">680</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD2</td> <td>What is a move constructor?</td> <td class="na" align="center">N/A</td> </tr> <tr id="681"> <td><a href="https://cplusplus.github.io/CWG/issues/681.html">681</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD1</td> <td>Restrictions on declarators with late-specified return types</td> <td class="partial" align="center">Partial</td> </tr> <tr id="682"> <td><a href="https://cplusplus.github.io/CWG/issues/682.html">682</a></td> + <td>[<a href="https://wg21.link/basic.lookup.classref">basic.lookup.classref</a>]</td> <td>CD5</td> <td>Missing description of lookup of template aliases</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="683"> <td><a href="https://cplusplus.github.io/CWG/issues/683.html">683</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD1</td> <td>Requirements for trivial subobject special functions</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr id="684"> <td><a href="https://cplusplus.github.io/CWG/issues/684.html">684</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD1</td> <td>Constant expressions involving the address of an automatic variable</td> <td class="unknown-superseded" align="center">Superseded by <a href="#1454">1454</a></td> </tr> <tr id="685"> <td><a href="https://cplusplus.github.io/CWG/issues/685.html">685</a></td> + <td>[<a href="https://wg21.link/conv.prom">conv.prom</a>]</td> <td>CD2</td> <td>Integral promotion of enumeration ignores fixed underlying type</td> <td class="full" align="center">Clang 10</td> </tr> <tr id="686"> <td><a href="https://cplusplus.github.io/CWG/issues/686.html">686</a></td> + <td>[<a href="https://wg21.link/dcl.name">dcl.name</a>]</td> <td>CD1</td> <td>Type declarations/definitions in <I>type-specifier-seq</I>s and <I>type-id</I>s</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="687"> <td><a href="https://cplusplus.github.io/CWG/issues/687.html">687</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>NAD</td> <td><TT>template</TT> keyword with <I>unqualified-id</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="688"> <td><a href="https://cplusplus.github.io/CWG/issues/688.html">688</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>CD1</td> <td>Constexpr constructors and static initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="689"> <td><a href="https://cplusplus.github.io/CWG/issues/689.html">689</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>CD5</td> <td>Maximum values of signed and unsigned integers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="690"> <td><a href="https://cplusplus.github.io/CWG/issues/690.html">690</a></td> + <td>[<a href="https://wg21.link/intro.defs">intro.defs</a>]</td> <td>CD2</td> <td>The dynamic type of an rvalue reference</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="691"> <td><a href="https://cplusplus.github.io/CWG/issues/691.html">691</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>C++11</td> <td>Template parameter packs in class template partial specializations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="692"> <td><a href="https://cplusplus.github.io/CWG/issues/692.html">692</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>C++11</td> <td>Partial ordering of variadic class template partial specializations</td> <td class="full" align="center">Clang 16</td> </tr> <tr id="693"> <td><a href="https://cplusplus.github.io/CWG/issues/693.html">693</a></td> + <td>[<a href="https://wg21.link/conv.array">conv.array</a>]</td> <td>CD2</td> <td>New string types and deprecated conversion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="694"> <td><a href="https://cplusplus.github.io/CWG/issues/694.html">694</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>C++11</td> <td>Zero- and value-initialization of union objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="695"> <td><a href="https://cplusplus.github.io/CWG/issues/695.html">695</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>CD2</td> <td>Compile-time calculation errors in constexpr functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="696"> <td><a href="https://cplusplus.github.io/CWG/issues/696.html">696</a></td> + <td>[<a href="https://wg21.link/class.local">class.local</a>]</td> <td>C++11</td> <td>Use of block-scope constants in local classes</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr class="open" id="697"> <td><a href="https://cplusplus.github.io/CWG/issues/697.html">697</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>open</td> <td>Deduction rules apply to more than functions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="698"> <td><a href="https://cplusplus.github.io/CWG/issues/698.html">698</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>open</td> <td>The definition of “sequenced before” is too narrow</td> <td align="center">Not resolved</td> </tr> <tr id="699"> <td><a href="https://cplusplus.github.io/CWG/issues/699.html">699</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD2</td> <td>Must constexpr member functions be defined in the class <I>member-specification</I>?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="700"> <td><a href="https://cplusplus.github.io/CWG/issues/700.html">700</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++11</td> <td>Constexpr member functions of class templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="701"> <td><a href="https://cplusplus.github.io/CWG/issues/701.html">701</a></td> + <td>[<a href="https://wg21.link/dcl.array">dcl.array</a>]</td> <td>CD2</td> <td>When is the array-to-pointer conversion applied?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="702"> <td><a href="https://cplusplus.github.io/CWG/issues/702.html">702</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>CD2</td> <td>Preferring conversion to <TT>std::initializer_list</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="703"> <td><a href="https://cplusplus.github.io/CWG/issues/703.html">703</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD2</td> <td>Narrowing for literals that cannot be exactly represented</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="704"> <td><a href="https://cplusplus.github.io/CWG/issues/704.html">704</a></td> + <td>[<a href="https://wg21.link/over.match.call">over.match.call</a>]</td> <td>CD2</td> <td>To which <I>postfix-expression</I>s does overload resolution apply?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="705"> <td><a href="https://cplusplus.github.io/CWG/issues/705.html">705</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>CD2</td> <td>Suppressing argument-dependent lookup via parentheses</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="706"> <td><a href="https://cplusplus.github.io/CWG/issues/706.html">706</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>NAD</td> <td>Use of <TT>auto</TT> with rvalue references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="707"> <td><a href="https://cplusplus.github.io/CWG/issues/707.html">707</a></td> + <td>[<a href="https://wg21.link/conv.fpint">conv.fpint</a>]</td> <td>CD2</td> <td>Undefined behavior in integral-to-floating conversions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="708"> <td><a href="https://cplusplus.github.io/CWG/issues/708.html">708</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial">temp.spec.partial</a>]</td> <td>open</td> <td>Partial specialization of member templates of class templates</td> <td align="center">Not resolved</td> </tr> <tr id="709"> <td><a href="https://cplusplus.github.io/CWG/issues/709.html">709</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>C++11</td> <td>Enumeration names as <I>nested-name-specifier</I>s in deduction failure</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="710"> <td><a href="https://cplusplus.github.io/CWG/issues/710.html">710</a></td> + <td>[<a href="https://wg21.link/class.cdtor">class.cdtor</a>]</td> <td>CD2</td> <td>Data races during construction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="711"> <td><a href="https://cplusplus.github.io/CWG/issues/711.html">711</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD2</td> <td><TT>auto</TT> with <I>braced-init-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="712"> <td><a href="https://cplusplus.github.io/CWG/issues/712.html">712</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD3</td> <td>Are integer constant operands of a <I>conditional-expression</I> “used?”</td> <td class="partial" align="center">Partial</td> </tr> <tr id="713"> <td><a href="https://cplusplus.github.io/CWG/issues/713.html">713</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD2</td> <td>Unclear note about cv-qualified function types</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="714"> <td><a href="https://cplusplus.github.io/CWG/issues/714.html">714</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>CD2</td> <td>Static const data members and <I>braced-init-list</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="715"> <td><a href="https://cplusplus.github.io/CWG/issues/715.html">715</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD2</td> <td>Class member access constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="716"> <td><a href="https://cplusplus.github.io/CWG/issues/716.html">716</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>CD2</td> <td>Specifications that should apply only to non-static union data members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="717"> <td><a href="https://cplusplus.github.io/CWG/issues/717.html">717</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>CD2</td> <td>Unintentional restrictions on the use of <TT>thread_local</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="718"> <td><a href="https://cplusplus.github.io/CWG/issues/718.html">718</a></td> + <td>[<a href="https://wg21.link/class.friend">class.friend</a>]</td> <td>NAD</td> <td>Non-class, non-function friend declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="719"> <td><a href="https://cplusplus.github.io/CWG/issues/719.html">719</a></td> + <td>[<a href="https://wg21.link/basic.pre">basic.pre</a>]</td> <td>CD2</td> <td>Specifications for <I>operator-function-id</I> that should also apply to <I>literal-operator-id</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="720"> <td><a href="https://cplusplus.github.io/CWG/issues/720.html">720</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD2</td> <td>Need examples of <I>lambda-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="721"> <td><a href="https://cplusplus.github.io/CWG/issues/721.html">721</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD2</td> <td>Where must a variable be initialized to be used in a constant expression?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="722"> <td><a href="https://cplusplus.github.io/CWG/issues/722.html">722</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD2</td> <td>Can <TT>nullptr</TT> be passed to an ellipsis?</td> <td class="full" align="center">Clang 20</td> </tr> <tr id="726"> <td><a href="https://cplusplus.github.io/CWG/issues/726.html">726</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>CD2</td> <td>Atomic and non-atomic objects in the memory model</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="727"> <td><a href="https://cplusplus.github.io/CWG/issues/727.html">727</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>C++17</td> <td>In-class explicit specializations</td> <td class="partial" align="center">Partial</td> </tr> <tr id="728"> <td><a href="https://cplusplus.github.io/CWG/issues/728.html">728</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>NAD</td> <td>Restrictions on local classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="729"> <td><a href="https://cplusplus.github.io/CWG/issues/729.html">729</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>CD3</td> <td>Qualification conversions and handlers of reference-to-pointer type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="730"> <td><a href="https://cplusplus.github.io/CWG/issues/730.html">730</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>CD2</td> <td>Explicit specializations of members of non-template classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="731"> <td><a href="https://cplusplus.github.io/CWG/issues/731.html">731</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>CD2</td> <td>Omitted reference qualification of member function type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="732"> <td><a href="https://cplusplus.github.io/CWG/issues/732.html">732</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def">dcl.fct.def</a>]</td> <td>CD2</td> <td>Late-specified return types in function definitions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="733"> <td><a href="https://cplusplus.github.io/CWG/issues/733.html">733</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>NAD</td> <td>Reference qualification of copy assignment operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="734"> <td><a href="https://cplusplus.github.io/CWG/issues/734.html">734</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>CD2</td> <td>Are unique addresses required for namespace-scope variables?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="735"> <td><a href="https://cplusplus.github.io/CWG/issues/735.html">735</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.safety">basic.stc.dynamic.safety</a>]</td> <td>CD2</td> <td>Missing case in specification of safely-derived pointers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="736"> <td><a href="https://cplusplus.github.io/CWG/issues/736.html">736</a></td> + <td>[<a href="https://wg21.link/dcl.decl">dcl.decl</a>]</td> <td>NAD</td> <td>Is the <TT>&</TT> <I>ref-qualifier</I> needed?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="737"> <td><a href="https://cplusplus.github.io/CWG/issues/737.html">737</a></td> + <td>[<a href="https://wg21.link/dcl.init.string">dcl.init.string</a>]</td> <td>CD2</td> <td>Uninitialized trailing characters in string initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="738"> <td><a href="https://cplusplus.github.io/CWG/issues/738.html">738</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>C++11</td> <td><TT>constexpr</TT> not permitted by the syntax of constructor declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="739"> <td><a href="https://cplusplus.github.io/CWG/issues/739.html">739</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>CD3</td> <td>Signedness of plain bit-fields</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="740"> <td><a href="https://cplusplus.github.io/CWG/issues/740.html">740</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>CD2</td> <td>Incorrect note on data races</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="741"> <td><a href="https://cplusplus.github.io/CWG/issues/741.html">741</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>C++11</td> <td>“plain” <TT>long long</TT> bit-fields</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="742"> <td><a href="https://cplusplus.github.io/CWG/issues/742.html">742</a></td> + <td>[<a href="https://wg21.link/expr.post.incr">expr.post.incr</a>]</td> <td>open</td> <td>Postfix increment/decrement with long bit-field operands</td> <td align="center">Not resolved</td> </tr> <tr id="743"> <td><a href="https://cplusplus.github.io/CWG/issues/743.html">743</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>CD2</td> <td>Use of <TT>decltype</TT> in a <I>nested-name-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="744"> <td><a href="https://cplusplus.github.io/CWG/issues/744.html">744</a></td> + <td>[<a href="https://wg21.link/temp.arg.template">temp.arg.template</a>]</td> <td>CD2</td> <td>Matching template arguments with template template parameters with parameter packs</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="745"> <td><a href="https://cplusplus.github.io/CWG/issues/745.html">745</a></td> + <td>[<a href="https://wg21.link/cpp.error">cpp.error</a>]</td> <td>C++23</td> <td>Effect of ill-formedness resulting from <TT>#error</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="746"> <td><a href="https://cplusplus.github.io/CWG/issues/746.html">746</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD2</td> <td>Use of <TT>auto</TT> in <I>new-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="747"> <td><a href="https://cplusplus.github.io/CWG/issues/747.html">747</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>dup</td> <td>Access of protected base classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="749"> <td><a href="https://cplusplus.github.io/CWG/issues/749.html">749</a></td> + <td>[<a href="https://wg21.link/over.built">over.built</a>]</td> <td>CD2</td> <td>References to function types with a <I>cv-qualifier</I> or <I>ref-qualifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="750"> <td><a href="https://cplusplus.github.io/CWG/issues/750.html">750</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD2</td> <td>Implementation constraints on reference-only closure objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="751"> <td><a href="https://cplusplus.github.io/CWG/issues/751.html">751</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD2</td> <td>Deriving from closure classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="752"> <td><a href="https://cplusplus.github.io/CWG/issues/752.html">752</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD2</td> <td>Name lookup in nested <I>lambda-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="753"> <td><a href="https://cplusplus.github.io/CWG/issues/753.html">753</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD2</td> <td>Array names in lambda capture sets</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="754"> <td><a href="https://cplusplus.github.io/CWG/issues/754.html">754</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD2</td> <td>Lambda expressions in default arguments of block-scope function declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="755"> <td><a href="https://cplusplus.github.io/CWG/issues/755.html">755</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD3</td> <td>Generalized <I>lambda-capture</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="756"> <td><a href="https://cplusplus.github.io/CWG/issues/756.html">756</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD2</td> <td>Dropping cv-qualification on members of closure objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="757"> <td><a href="https://cplusplus.github.io/CWG/issues/757.html">757</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD2</td> <td>Types without linkage in declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="758"> <td><a href="https://cplusplus.github.io/CWG/issues/758.html">758</a></td> + <td>[<a href="https://wg21.link/basic.def">basic.def</a>]</td> <td>C++11</td> <td>Missing cases of declarations that are not definitions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="759"> <td><a href="https://cplusplus.github.io/CWG/issues/759.html">759</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD2</td> <td>Destruction of closure objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="760"> <td><a href="https://cplusplus.github.io/CWG/issues/760.html">760</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>CD2</td> <td><TT>this</TT> inside a nested class of a non-static member function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="761"> <td><a href="https://cplusplus.github.io/CWG/issues/761.html">761</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD2</td> <td>Inferred return type of closure object call operator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="762"> <td><a href="https://cplusplus.github.io/CWG/issues/762.html">762</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD2</td> <td>Name lookup in the <I>compound-statement</I> of a lambda expression</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="763"> <td><a href="https://cplusplus.github.io/CWG/issues/763.html">763</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD2</td> <td>Is a closure object's <TT>operator()</TT> inline?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="764"> <td><a href="https://cplusplus.github.io/CWG/issues/764.html">764</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD2</td> <td>Capturing unused variables in a lambda expression</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="765"> <td><a href="https://cplusplus.github.io/CWG/issues/765.html">765</a></td> + <td>[<a href="https://wg21.link/dcl.fct.spec">dcl.fct.spec</a>]</td> <td>CD2</td> <td>Local types in inline functions with external linkage</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="766"> <td><a href="https://cplusplus.github.io/CWG/issues/766.html">766</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD2</td> <td>Where may lambda expressions appear?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="767"> <td><a href="https://cplusplus.github.io/CWG/issues/767.html">767</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD2</td> <td><TT>void</TT> and other unnamed <I>lambda-parameter</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="768"> <td><a href="https://cplusplus.github.io/CWG/issues/768.html">768</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD2</td> <td>Ellipsis in a lambda parameter list</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="769"> <td><a href="https://cplusplus.github.io/CWG/issues/769.html">769</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD2</td> <td>Initialization of closure objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="770"> <td><a href="https://cplusplus.github.io/CWG/issues/770.html">770</a></td> + <td>[<a href="https://wg21.link/dcl.decl">dcl.decl</a>]</td> <td>CD2</td> <td>Ambiguity in late-specified return type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="771"> <td><a href="https://cplusplus.github.io/CWG/issues/771.html">771</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD2</td> <td>Move-construction of reference members of closure objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="772"> <td><a href="https://cplusplus.github.io/CWG/issues/772.html">772</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD2</td> <td><I>capture-default</I> in lambdas in local default arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="773"> <td><a href="https://cplusplus.github.io/CWG/issues/773.html">773</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>C++11</td> <td>Parentheses in address non-type template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="774"> <td><a href="https://cplusplus.github.io/CWG/issues/774.html">774</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD2</td> <td>Can a closure class be a POD?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="775"> <td><a href="https://cplusplus.github.io/CWG/issues/775.html">775</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD2</td> <td>Capturing references to functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="776"> <td><a href="https://cplusplus.github.io/CWG/issues/776.html">776</a></td> + <td>[<a href="https://wg21.link/basic.start.dynamic">basic.start.dynamic</a>]</td> <td>CD2</td> <td>Delegating constructors, destructors, and <TT>std::exit</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="777"> <td><a href="https://cplusplus.github.io/CWG/issues/777.html">777</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>CD2</td> <td>Default arguments and parameter packs</td> <td class="full" align="center">Clang 3.7</td> </tr> <tr id="778"> <td><a href="https://cplusplus.github.io/CWG/issues/778.html">778</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>C++11</td> <td>Template parameter packs in non-type template parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="779"> <td><a href="https://cplusplus.github.io/CWG/issues/779.html">779</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD2</td> <td>Rvalue reference members of closure objects?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="782"> <td><a href="https://cplusplus.github.io/CWG/issues/782.html">782</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD2</td> <td>Lambda expressions and argument-dependent lookup</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="783"> <td><a href="https://cplusplus.github.io/CWG/issues/783.html">783</a></td> + <td>[<a href="https://wg21.link/intro.defs">intro.defs</a>]</td> <td>open</td> <td>Definition of “argument”</td> <td align="center">Not resolved</td> </tr> <tr id="784"> <td><a href="https://cplusplus.github.io/CWG/issues/784.html">784</a></td> + <td>[<a href="https://wg21.link/intro.structure">intro.structure</a>]</td> <td>C++11</td> <td>List of incompatibilities with the previous Standard</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="785"> <td><a href="https://cplusplus.github.io/CWG/issues/785.html">785</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>CD2</td> <td>“Execution sequence” is inappropriate phraseology</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="786"> <td><a href="https://cplusplus.github.io/CWG/issues/786.html">786</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>CD2</td> <td>Definition of “thread”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="787"> <td><a href="https://cplusplus.github.io/CWG/issues/787.html">787</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>CD2</td> <td>Unnecessary lexical undefined behavior</td> <td class="full" align="center">Clang 21</td> </tr> <tr id="788"> <td><a href="https://cplusplus.github.io/CWG/issues/788.html">788</a></td> + <td>[<a href="https://wg21.link/lex.charset">lex.charset</a>]</td> <td>CD2</td> <td>Relationship between locale and values of the execution character set</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="789"> <td><a href="https://cplusplus.github.io/CWG/issues/789.html">789</a></td> + <td>[<a href="https://wg21.link/lex.trigraph">lex.trigraph</a>]</td> <td>CD2</td> <td>Deprecating trigraphs</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="790"> <td><a href="https://cplusplus.github.io/CWG/issues/790.html">790</a></td> + <td>[<a href="https://wg21.link/lex.string">lex.string</a>]</td> <td>CD2</td> <td>Concatenation of raw and non-raw string literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="792"> <td><a href="https://cplusplus.github.io/CWG/issues/792.html">792</a></td> + <td>[<a href="https://wg21.link/basic.start.main">basic.start.main</a>]</td> <td>CD2</td> <td>Effects of <TT>std::quick_exit</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="793"> <td><a href="https://cplusplus.github.io/CWG/issues/793.html">793</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD2</td> <td>Use of class members during destruction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="794"> <td><a href="https://cplusplus.github.io/CWG/issues/794.html">794</a></td> + <td>[<a href="https://wg21.link/conv.mem">conv.mem</a>]</td> <td>NAD</td> <td>Base-derived conversion in member type of pointer-to-member conversion</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="795"> <td><a href="https://cplusplus.github.io/CWG/issues/795.html">795</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>NAD</td> <td>Dependency of lambdas on <TT><functional></TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="796"> <td><a href="https://cplusplus.github.io/CWG/issues/796.html">796</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD2</td> <td>Lifetime of a closure object with members captured by reference</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="797"> <td><a href="https://cplusplus.github.io/CWG/issues/797.html">797</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD2</td> <td>Converting a no-capture lambda to a function type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="798"> <td><a href="https://cplusplus.github.io/CWG/issues/798.html">798</a></td> + <td>[<a href="https://wg21.link/expr.sub">expr.sub</a>]</td> <td>C++11</td> <td>Overloaded subscript operator described in clause 5</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="799"> <td><a href="https://cplusplus.github.io/CWG/issues/799.html">799</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>CD2</td> <td>Can <TT>reinterpret_cast</TT> be used to cast an operand to its own type?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="800"> <td><a href="https://cplusplus.github.io/CWG/issues/800.html">800</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>NAD</td> <td>Safely-derived pointers and object pointers converted from function pointers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="801"> <td><a href="https://cplusplus.github.io/CWG/issues/801.html">801</a></td> + <td>[<a href="https://wg21.link/expr.const.cast">expr.const.cast</a>]</td> <td>CD2</td> <td>Casting away constness in a cast to rvalue reference type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="803"> <td><a href="https://cplusplus.github.io/CWG/issues/803.html">803</a></td> + <td>[<a href="https://wg21.link/expr.sizeof">expr.sizeof</a>]</td> <td>CD2</td> <td><TT>sizeof</TT> an enumeration type with a fixed underlying type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="804"> <td><a href="https://cplusplus.github.io/CWG/issues/804.html">804</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD2</td> <td>Deducing the type in <TT>new auto(x)</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="805"> <td><a href="https://cplusplus.github.io/CWG/issues/805.html">805</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD2</td> <td>Which exception to throw for overflow in array size calculation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="806"> <td><a href="https://cplusplus.github.io/CWG/issues/806.html">806</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD2</td> <td>Enumeration types in integral constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="807"> <td><a href="https://cplusplus.github.io/CWG/issues/807.html">807</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td><TT>typeid</TT> expressions in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="808"> <td><a href="https://cplusplus.github.io/CWG/issues/808.html">808</a></td> + <td>[<a href="https://wg21.link/dcl.spec">dcl.spec</a>]</td> <td>CD2</td> <td>Non-type <I>decl-specifier</I>s versus max-munch</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="809"> <td><a href="https://cplusplus.github.io/CWG/issues/809.html">809</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>CD2</td> <td>Deprecation of the <TT>register</TT> keyword</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="810"> <td><a href="https://cplusplus.github.io/CWG/issues/810.html">810</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>CD2</td> <td>Block-scope <TT>thread_local</TT> variables should be implicitly <TT>static</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="811"> <td><a href="https://cplusplus.github.io/CWG/issues/811.html">811</a></td> + <td>[<a href="https://wg21.link/dcl.type.cv">dcl.type.cv</a>]</td> <td>CD2</td> <td>Unclear implications of const-qualification</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="812"> <td><a href="https://cplusplus.github.io/CWG/issues/812.html">812</a></td> + <td>[<a href="https://wg21.link/namespace.def">namespace.def</a>]</td> <td>CD2</td> <td>Duplicate names in inline namespaces</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="813"> <td><a href="https://cplusplus.github.io/CWG/issues/813.html">813</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>open</td> <td><TT>typename</TT> in a <I>using-declaration</I> with a non-dependent name</td> <td align="center">Not resolved</td> </tr> <tr id="814"> <td><a href="https://cplusplus.github.io/CWG/issues/814.html">814</a></td> + <td>[<a href="https://wg21.link/dcl.attr">dcl.attr</a>]</td> <td>CD2</td> <td>Attribute to indicate that a function throws nothing</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="815"> <td><a href="https://cplusplus.github.io/CWG/issues/815.html">815</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>CD2</td> <td>Parameter pack expansion inside attributes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="816"> <td><a href="https://cplusplus.github.io/CWG/issues/816.html">816</a></td> + <td>[<a href="https://wg21.link/dcl.attr.final">dcl.attr.final</a>]</td> <td>CD2</td> <td>Diagnosing violations of <TT>[[final]]</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="817"> <td><a href="https://cplusplus.github.io/CWG/issues/817.html">817</a></td> + <td>[<a href="https://wg21.link/dcl.attr.final">dcl.attr.final</a>]</td> <td>CD2</td> <td>Meaning of <TT>[[final]]</TT> applied to a class definition</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="818"> <td><a href="https://cplusplus.github.io/CWG/issues/818.html">818</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD2</td> <td>Function parameter packs in non-final positions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="819"> <td><a href="https://cplusplus.github.io/CWG/issues/819.html">819</a></td> + <td>[<a href="https://wg21.link/special">special</a>]</td> <td>NAD</td> <td>Access control and deleted implicitly-declared special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="820"> <td><a href="https://cplusplus.github.io/CWG/issues/820.html">820</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>CD2</td> <td>Deprecation of <TT>export</TT></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="822"> <td><a href="https://cplusplus.github.io/CWG/issues/822.html">822</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>NAD</td> <td>Additional contexts for template aliases</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="823"> <td><a href="https://cplusplus.github.io/CWG/issues/823.html">823</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>CD2</td> <td>Literal types with constexpr conversions as non-type template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="828"> <td><a href="https://cplusplus.github.io/CWG/issues/828.html">828</a></td> + <td>[<a href="https://wg21.link/except.throw">except.throw</a>]</td> <td>CD2</td> <td>Destruction of exception objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="829"> <td><a href="https://cplusplus.github.io/CWG/issues/829.html">829</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>NAD</td> <td>At what point is <TT>std::unexpected</TT> called?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="830"> <td><a href="https://cplusplus.github.io/CWG/issues/830.html">830</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD2</td> <td>Deprecating exception specifications</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="831"> <td><a href="https://cplusplus.github.io/CWG/issues/831.html">831</a></td> + <td>[<a href="https://wg21.link/implimits">implimits</a>]</td> <td>CD2</td> <td>Limit on recursively nested template instantiations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="832"> <td><a href="https://cplusplus.github.io/CWG/issues/832.html">832</a></td> + <td>[<a href="https://wg21.link/lex.ppnumber">lex.ppnumber</a>]</td> <td>CD2</td> <td>Value of preprocessing numbers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="833"> <td><a href="https://cplusplus.github.io/CWG/issues/833.html">833</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD2</td> <td>Explicit conversion of a scoped enumeration value to a floating type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="834"> <td><a href="https://cplusplus.github.io/CWG/issues/834.html">834</a></td> + <td>[<a href="https://wg21.link/lex.string">lex.string</a>]</td> <td>CD2</td> <td>What is an “ordinary string literal”?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="835"> <td><a href="https://cplusplus.github.io/CWG/issues/835.html">835</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>CD2</td> <td>Scoped enumerations and the “usual arithmetic conversions”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="836"> <td><a href="https://cplusplus.github.io/CWG/issues/836.html">836</a></td> + <td>[<a href="https://wg21.link/dcl.attr.noreturn">dcl.attr.noreturn</a>]</td> <td>NAD</td> <td><TT>[[noreturn]]</TT> applied to function types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="837"> <td><a href="https://cplusplus.github.io/CWG/issues/837.html">837</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++11</td> <td>Constexpr functions and <TT>return</TT> <I>braced-init-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="838"> <td><a href="https://cplusplus.github.io/CWG/issues/838.html">838</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>C++11</td> <td>Use of <TT>this</TT> in a <I>brace-or-equal-initializer</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="839"> <td><a href="https://cplusplus.github.io/CWG/issues/839.html">839</a></td> + <td>[<a href="https://wg21.link/expr.sizeof">expr.sizeof</a>]</td> <td>dup</td> <td><TT>sizeof</TT> with opaque enumerations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="840"> <td><a href="https://cplusplus.github.io/CWG/issues/840.html">840</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>CD2</td> <td>Rvalue references as nontype template parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="842"> <td><a href="https://cplusplus.github.io/CWG/issues/842.html">842</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>CD2</td> <td>Casting to rvalue reference type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="845"> <td><a href="https://cplusplus.github.io/CWG/issues/845.html">845</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def">dcl.fct.def</a>]</td> <td>CD2</td> <td>What is the “first declaration” of an explicit specialization?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="846"> <td><a href="https://cplusplus.github.io/CWG/issues/846.html">846</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>CD2</td> <td>Rvalue references to functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="847"> <td><a href="https://cplusplus.github.io/CWG/issues/847.html">847</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>CD2</td> <td>Error in rvalue reference deduction example</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="850"> <td><a href="https://cplusplus.github.io/CWG/issues/850.html">850</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>CD2</td> <td>Restrictions on use of non-static data members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="852"> <td><a href="https://cplusplus.github.io/CWG/issues/852.html">852</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD6</td> <td><I>using-declaration</I>s and dependent base classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="853"> <td><a href="https://cplusplus.github.io/CWG/issues/853.html">853</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.safety">basic.stc.dynamic.safety</a>]</td> <td>CD2</td> <td>Support for relaxed pointer safety</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="854"> <td><a href="https://cplusplus.github.io/CWG/issues/854.html">854</a></td> + <td>[<a href="https://wg21.link/expr.shift">expr.shift</a>]</td> <td>CD2</td> <td>Left shift and unsigned extended types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="855"> <td><a href="https://cplusplus.github.io/CWG/issues/855.html">855</a></td> + <td>[<a href="https://wg21.link/expr.assign">expr.assign</a>]</td> <td>CD2</td> <td>Incorrect comments in <I>braced-init-list</I> assignment example</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="858"> <td><a href="https://cplusplus.github.io/CWG/issues/858.html">858</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>CD2</td> <td>Example binding an rvalue reference to an lvalue</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="860"> <td><a href="https://cplusplus.github.io/CWG/issues/860.html">860</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++11</td> <td>Explicit qualification of constexpr member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="861"> <td><a href="https://cplusplus.github.io/CWG/issues/861.html">861</a></td> + <td>[<a href="https://wg21.link/namespace.qual">namespace.qual</a>]</td> <td>CD2</td> <td>Unintended ambiguity in inline namespace lookup</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="862"> <td><a href="https://cplusplus.github.io/CWG/issues/862.html">862</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD2</td> <td>Undefined behavior with enumerator value overflow</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="863"> <td><a href="https://cplusplus.github.io/CWG/issues/863.html">863</a></td> + <td>[<a href="https://wg21.link/expr.post">expr.post</a>]</td> <td>CD2</td> <td>Rvalue reference cast to incomplete type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="864"> <td><a href="https://cplusplus.github.io/CWG/issues/864.html">864</a></td> + <td>[<a href="https://wg21.link/stmt.ranged">stmt.ranged</a>]</td> <td>C++11</td> <td><I>braced-init-list</I> in the range-based <TT>for</TT> statement</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="865"> <td><a href="https://cplusplus.github.io/CWG/issues/865.html">865</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD2</td> <td>Initializing a <TT>std::initializer_list</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="869"> <td><a href="https://cplusplus.github.io/CWG/issues/869.html">869</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD2</td> <td>Uninitialized <TT>thread_local</TT> objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="872"> <td><a href="https://cplusplus.github.io/CWG/issues/872.html">872</a></td> + <td>[<a href="https://wg21.link/lex.string">lex.string</a>]</td> <td>CD2</td> <td>Lexical issues with raw strings</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="873"> <td><a href="https://cplusplus.github.io/CWG/issues/873.html">873</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>C++11</td> <td>Deducing rvalue references in declarative contexts</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="874"> <td><a href="https://cplusplus.github.io/CWG/issues/874.html">874</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD2</td> <td>Class-scope definitions of enumeration types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="876"> <td><a href="https://cplusplus.github.io/CWG/issues/876.html">876</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>CD2</td> <td>Type references in rvalue reference deduction specification</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="877"> <td><a href="https://cplusplus.github.io/CWG/issues/877.html">877</a></td> + <td>[<a href="https://wg21.link/over.match.viable">over.match.viable</a>]</td> <td>CD2</td> <td>Viable functions and binding references to rvalues</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="879"> <td><a href="https://cplusplus.github.io/CWG/issues/879.html">879</a></td> + <td>[<a href="https://wg21.link/over.built">over.built</a>]</td> <td>CD2</td> <td>Missing built-in comparison operators for pointer types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="880"> <td><a href="https://cplusplus.github.io/CWG/issues/880.html">880</a></td> + <td>[<a href="https://wg21.link/over.built">over.built</a>]</td> <td>CD2</td> <td>Built-in conditional operator for scoped enumerations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="882"> <td><a href="https://cplusplus.github.io/CWG/issues/882.html">882</a></td> + <td>[<a href="https://wg21.link/basic.start.main">basic.start.main</a>]</td> <td>CD2</td> <td>Defining <TT>main</TT> as deleted</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="883"> <td><a href="https://cplusplus.github.io/CWG/issues/883.html">883</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>CD2</td> <td><TT>std::memcpy</TT> vs <TT>std::memmove</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="884"> <td><a href="https://cplusplus.github.io/CWG/issues/884.html">884</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>CD2</td> <td>Defining an explicitly-specialized static data member</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="885"> <td><a href="https://cplusplus.github.io/CWG/issues/885.html">885</a></td> + <td>[<a href="https://wg21.link/temp.deduct.partial">temp.deduct.partial</a>]</td> <td>NAD</td> <td>Partial ordering of function templates with unordered parameter pairs</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="886"> <td><a href="https://cplusplus.github.io/CWG/issues/886.html">886</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>CD2</td> <td>Member initializers and aggregates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="887"> <td><a href="https://cplusplus.github.io/CWG/issues/887.html">887</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD2</td> <td>Move construction of thrown object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="888"> <td><a href="https://cplusplus.github.io/CWG/issues/888.html">888</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>CD2</td> <td>Union member initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="891"> <td><a href="https://cplusplus.github.io/CWG/issues/891.html">891</a></td> + <td>[<a href="https://wg21.link/expr.const.cast">expr.const.cast</a>]</td> <td>CD2</td> <td><TT>const_cast</TT> to rvalue reference from objectless rvalue</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="892"> <td><a href="https://cplusplus.github.io/CWG/issues/892.html">892</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++11</td> <td>Missing requirements for constexpr constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="893"> <td><a href="https://cplusplus.github.io/CWG/issues/893.html">893</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>NAD</td> <td>Brace syntax for <I>enumerator-definition</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="896"> <td><a href="https://cplusplus.github.io/CWG/issues/896.html">896</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD2</td> <td>Rvalue references and rvalue-reference conversion functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="897"> <td><a href="https://cplusplus.github.io/CWG/issues/897.html">897</a></td> + <td>[<a href="https://wg21.link/cpp.pragma.op">cpp.pragma.op</a>]</td> <td>open</td> <td><TT>_Pragma</TT> and extended <I>string-literal</I>s</td> <td align="center">Not resolved</td> </tr> <tr id="898"> <td><a href="https://cplusplus.github.io/CWG/issues/898.html">898</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++11</td> <td>Declarations in constexpr functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="899"> <td><a href="https://cplusplus.github.io/CWG/issues/899.html">899</a></td> + <td>[<a href="https://wg21.link/over.match.copy">over.match.copy</a>]</td> <td>CD2</td> <td>Explicit conversion functions in direct class initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="900"> <td><a href="https://cplusplus.github.io/CWG/issues/900.html">900</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>C++23</td> <td>Lifetime of temporaries in range-based <TT>for</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="901"> <td><a href="https://cplusplus.github.io/CWG/issues/901.html">901</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>open</td> <td>Deleted <TT>operator delete</TT></td> <td align="center">Not resolved</td> </tr> <tr id="902"> <td><a href="https://cplusplus.github.io/CWG/issues/902.html">902</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>NAD</td> <td>In-class initialization of non-constant static data members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="903"> <td><a href="https://cplusplus.github.io/CWG/issues/903.html">903</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>CD3</td> <td>Value-dependent integral null pointer constants</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="904"> <td><a href="https://cplusplus.github.io/CWG/issues/904.html">904</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD2</td> <td>Parameter packs in <I>lambda-capture</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="905"> <td><a href="https://cplusplus.github.io/CWG/issues/905.html">905</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD2</td> <td>Explicit defaulted copy constructors and trivial copyability</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="906"> <td><a href="https://cplusplus.github.io/CWG/issues/906.html">906</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def">dcl.fct.def</a>]</td> <td>CD2</td> <td>Which special member functions can be defaulted?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="908"> <td><a href="https://cplusplus.github.io/CWG/issues/908.html">908</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def">dcl.fct.def</a>]</td> <td>CD2</td> <td>Deleted global allocation and deallocation functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="909"> <td><a href="https://cplusplus.github.io/CWG/issues/909.html">909</a></td> + <td>[<a href="https://wg21.link/expr.cast">expr.cast</a>]</td> <td>NAD</td> <td>Old-style casts with conversion functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="910"> <td><a href="https://cplusplus.github.io/CWG/issues/910.html">910</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD2</td> <td>Move constructors and implicitly-declared copy constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="912"> <td><a href="https://cplusplus.github.io/CWG/issues/912.html">912</a></td> + <td>[<a href="https://wg21.link/lex.ccon">lex.ccon</a>]</td> <td>CD3</td> <td>Character literals and <I>universal-character-name</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="913"> <td><a href="https://cplusplus.github.io/CWG/issues/913.html">913</a></td> + <td>[<a href="https://wg21.link/temp.deduct.conv">temp.deduct.conv</a>]</td> <td>CD2</td> <td>Deduction rules for array- and function-type conversion functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="914"> <td><a href="https://cplusplus.github.io/CWG/issues/914.html">914</a></td> + <td>[<a href="https://wg21.link/expr.type.conv">expr.type.conv</a>]</td> <td>open</td> <td>Value-initialization of array types</td> <td align="center">Not resolved</td> </tr> <tr id="915"> <td><a href="https://cplusplus.github.io/CWG/issues/915.html">915</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def">dcl.fct.def</a>]</td> <td>CD2</td> <td>Deleted specializations of member function templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="919"> <td><a href="https://cplusplus.github.io/CWG/issues/919.html">919</a></td> + <td>[<a href="https://wg21.link/namespace.def">namespace.def</a>]</td> <td>CD2</td> <td>Contradictions regarding inline namespaces</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="920"> <td><a href="https://cplusplus.github.io/CWG/issues/920.html">920</a></td> + <td>[<a href="https://wg21.link/dcl.meaning">dcl.meaning</a>]</td> <td>CD2</td> <td>Interaction of inline namespaces and <I>using-declaration</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="921"> <td><a href="https://cplusplus.github.io/CWG/issues/921.html">921</a></td> + <td>[<a href="https://wg21.link/namespace.def">namespace.def</a>]</td> <td>CD2</td> <td>Unclear specification of inline namespaces</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="922"> <td><a href="https://cplusplus.github.io/CWG/issues/922.html">922</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>CD2</td> <td>Implicit default constructor definitions and <TT>const</TT> variant members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="923"> <td><a href="https://cplusplus.github.io/CWG/issues/923.html">923</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>CD2</td> <td>Inline explicit specializations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="924"> <td><a href="https://cplusplus.github.io/CWG/issues/924.html">924</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>C++11</td> <td><I>alias-declaration</I> as a class member</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="925"> <td><a href="https://cplusplus.github.io/CWG/issues/925.html">925</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>open</td> <td>Type of character literals in preprocessor expressions</td> <td align="center">Not resolved</td> </tr> <tr id="926"> <td><a href="https://cplusplus.github.io/CWG/issues/926.html">926</a></td> + <td>[<a href="https://wg21.link/namespace.unnamed">namespace.unnamed</a>]</td> <td>CD2</td> <td>Inline unnamed namespaces</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="927"> <td><a href="https://cplusplus.github.io/CWG/issues/927.html">927</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>CD2</td> <td>Implicitly-deleted default constructors and member initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="928"> <td><a href="https://cplusplus.github.io/CWG/issues/928.html">928</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def">dcl.fct.def</a>]</td> <td>CD2</td> <td>Defaulting a function that would be implicitly defined as deleted</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="929"> <td><a href="https://cplusplus.github.io/CWG/issues/929.html">929</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>CD2</td> <td>What is a template alias?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="930"> <td><a href="https://cplusplus.github.io/CWG/issues/930.html">930</a></td> + <td>[<a href="https://wg21.link/expr.alignof">expr.alignof</a>]</td> <td>CD2</td> <td><TT>alignof</TT> with incomplete array type</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="931"> <td><a href="https://cplusplus.github.io/CWG/issues/931.html">931</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>CD2</td> <td>Confusing reference to the length of a user-defined string literal</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="932"> <td><a href="https://cplusplus.github.io/CWG/issues/932.html">932</a></td> + <td>[<a href="https://wg21.link/lex.string">lex.string</a>]</td> <td>CD2</td> <td>UCNs in closing delimiters of raw string literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="933"> <td><a href="https://cplusplus.github.io/CWG/issues/933.html">933</a></td> + <td>[<a href="https://wg21.link/lex.ccon">lex.ccon</a>]</td> <td>CD2</td> <td>32-bit UCNs with 16-bit <TT>wchar_t</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="934"> <td><a href="https://cplusplus.github.io/CWG/issues/934.html">934</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD2</td> <td>List-initialization of references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="935"> <td><a href="https://cplusplus.github.io/CWG/issues/935.html">935</a></td> + <td>[<a href="https://wg21.link/over.literal">over.literal</a>]</td> <td>CD2</td> <td>Missing overloads for character types for user-defined literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="936"> <td><a href="https://cplusplus.github.io/CWG/issues/936.html">936</a></td> + <td>[<a href="https://wg21.link/dcl.init.string">dcl.init.string</a>]</td> <td>CD2</td> <td>Array initialization with new string literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="937"> <td><a href="https://cplusplus.github.io/CWG/issues/937.html">937</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>NAD</td> <td>Restrictions on values of template arguments in user-defined literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="938"> <td><a href="https://cplusplus.github.io/CWG/issues/938.html">938</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>C++11</td> <td>Initializer lists and array new</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="939"> <td><a href="https://cplusplus.github.io/CWG/issues/939.html">939</a></td> + <td>[<a href="https://wg21.link/class.virtual">class.virtual</a>]</td> <td>CD2</td> <td>Explicitly checking virtual function overriding</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="940"> <td><a href="https://cplusplus.github.io/CWG/issues/940.html">940</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>CD2</td> <td>Global anonymous unions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="941"> <td><a href="https://cplusplus.github.io/CWG/issues/941.html">941</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>C++11</td> <td>Explicit specialization of deleted function template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="942"> <td><a href="https://cplusplus.github.io/CWG/issues/942.html">942</a></td> + <td>[<a href="https://wg21.link/basic.pre">basic.pre</a>]</td> <td>CD2</td> <td>Is <TT>this</TT> an entity?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="943"> <td><a href="https://cplusplus.github.io/CWG/issues/943.html">943</a></td> + <td>[<a href="https://wg21.link/expr.type.conv">expr.type.conv</a>]</td> <td>CD5</td> <td>Is <TT>T()</TT> a temporary?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="944"> <td><a href="https://cplusplus.github.io/CWG/issues/944.html">944</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>NAD</td> <td><TT>reinterpret_cast</TT> for all types with the same size and alignment</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="945"> <td><a href="https://cplusplus.github.io/CWG/issues/945.html">945</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>C++11</td> <td>Use of <TT>this</TT> in a late-specified return type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="946"> <td><a href="https://cplusplus.github.io/CWG/issues/946.html">946</a></td> + <td>[<a href="https://wg21.link/basic.start.dynamic">basic.start.dynamic</a>]</td> <td>CD2</td> <td>Order of destruction of local static objects and calls to <TT>std::atexit</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="947"> <td><a href="https://cplusplus.github.io/CWG/issues/947.html">947</a></td> + <td>[<a href="https://wg21.link/temp.over">temp.over</a>]</td> <td>NAD</td> <td>Deducing type template arguments from default function arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="948"> <td><a href="https://cplusplus.github.io/CWG/issues/948.html">948</a></td> + <td>[<a href="https://wg21.link/stmt.select">stmt.select</a>]</td> <td>C++11</td> <td><TT>constexpr</TT> in <I>condition</I>s</td> <td class="full" align="center">Clang 3.7</td> </tr> <tr class="open" id="949"> <td><a href="https://cplusplus.github.io/CWG/issues/949.html">949</a></td> + <td>[<a href="https://wg21.link/intro.compliance">intro.compliance</a>]</td> <td>open</td> <td>Requirements for freestanding implementations</td> <td align="center">Not resolved</td> </tr> <tr id="950"> <td><a href="https://cplusplus.github.io/CWG/issues/950.html">950</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>CD2</td> <td>Use of <TT>decltype</TT> as a <I>class-name</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="951"> <td><a href="https://cplusplus.github.io/CWG/issues/951.html">951</a></td> + <td>[<a href="https://wg21.link/dcl.attr">dcl.attr</a>]</td> <td>CD2</td> <td>Problems with <I>attribute-specifier</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="952"> <td><a href="https://cplusplus.github.io/CWG/issues/952.html">952</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>CD6</td> <td>Insufficient description of “naming class”</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="953"> <td><a href="https://cplusplus.github.io/CWG/issues/953.html">953</a></td> + <td>[<a href="https://wg21.link/over.ics.ref">over.ics.ref</a>]</td> <td>CD2</td> <td>Rvalue references and function viability</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="954"> <td><a href="https://cplusplus.github.io/CWG/issues/954.html">954</a></td> + <td>[<a href="https://wg21.link/over.built">over.built</a>]</td> <td>open</td> <td>Overload resolution of conversion operator templates with built-in types</td> <td align="center">Not resolved</td> </tr> <tr id="955"> <td><a href="https://cplusplus.github.io/CWG/issues/955.html">955</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD2</td> <td>Can a closure type's <TT>operator()</TT> be virtual?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="956"> <td><a href="https://cplusplus.github.io/CWG/issues/956.html">956</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD2</td> <td>Function prototype scope with late-specified return types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="957"> <td><a href="https://cplusplus.github.io/CWG/issues/957.html">957</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>CD2</td> <td>Alternative tokens and <I>attribute-token</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="958"> <td><a href="https://cplusplus.github.io/CWG/issues/958.html">958</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>NAD</td> <td>Lambdas and <TT>decltype</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="959"> <td><a href="https://cplusplus.github.io/CWG/issues/959.html">959</a></td> + <td>[<a href="https://wg21.link/dcl.align">dcl.align</a>]</td> <td>CD2</td> <td>Alignment attribute for class and enumeration types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="960"> <td><a href="https://cplusplus.github.io/CWG/issues/960.html">960</a></td> + <td>[<a href="https://wg21.link/class.virtual">class.virtual</a>]</td> <td>CD2</td> <td>Covariant functions and lvalue/rvalue references</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="961"> <td><a href="https://cplusplus.github.io/CWG/issues/961.html">961</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>CD2</td> <td>Overload resolution and conversion of <TT>std::nullptr_t</TT> to <TT>bool</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="962"> <td><a href="https://cplusplus.github.io/CWG/issues/962.html">962</a></td> + <td>[<a href="https://wg21.link/dcl.type.elab">dcl.type.elab</a>]</td> <td>CD2</td> <td>Attributes appertaining to class and enum types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="963"> <td><a href="https://cplusplus.github.io/CWG/issues/963.html">963</a></td> + <td>[<a href="https://wg21.link/expr.rel">expr.rel</a>]</td> <td>CD2</td> <td>Comparing <TT>nullptr</TT> with 0</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="964"> <td><a href="https://cplusplus.github.io/CWG/issues/964.html">964</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>C++11</td> <td>Incorrect description of when the lvalue-to-rvalue conversion applies</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="965"> <td><a href="https://cplusplus.github.io/CWG/issues/965.html">965</a></td> + <td>[<a href="https://wg21.link/dcl.attr.depend">dcl.attr.depend</a>]</td> <td>CD2</td> <td>Limiting the applicability of the <TT>carries_dependency</TT> attribute</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="966"> <td><a href="https://cplusplus.github.io/CWG/issues/966.html">966</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD2</td> <td>Nested types without linkage</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="967"> <td><a href="https://cplusplus.github.io/CWG/issues/967.html">967</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic">basic.stc.dynamic</a>]</td> <td>NAD</td> <td>Exception specification of replacement allocation function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="968"> <td><a href="https://cplusplus.github.io/CWG/issues/968.html">968</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>CD2</td> <td>Syntactic ambiguity of the attribute notation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="969"> <td><a href="https://cplusplus.github.io/CWG/issues/969.html">969</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>CD2</td> <td>Explicit instantiation declarations of class template specializations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="970"> <td><a href="https://cplusplus.github.io/CWG/issues/970.html">970</a></td> + <td>[<a href="https://wg21.link/dcl.attr">dcl.attr</a>]</td> <td>CD2</td> <td>Consistent use of “appertain” and “apply”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="971"> <td><a href="https://cplusplus.github.io/CWG/issues/971.html">971</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>C++11</td> <td>Incorrect treatment of <I>exception-declaration</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="972"> <td><a href="https://cplusplus.github.io/CWG/issues/972.html">972</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>C++11</td> <td>Allowing multiple <I>attribute-specifier</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="973"> <td><a href="https://cplusplus.github.io/CWG/issues/973.html">973</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD2</td> <td>Function types in <I>exception-specification</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="974"> <td><a href="https://cplusplus.github.io/CWG/issues/974.html">974</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD3</td> <td>Default arguments for lambdas</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr id="975"> <td><a href="https://cplusplus.github.io/CWG/issues/975.html">975</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD3</td> <td>Restrictions on return type deduction for lambdas</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="976"> <td><a href="https://cplusplus.github.io/CWG/issues/976.html">976</a></td> + <td>[<a href="https://wg21.link/temp.deduct.conv">temp.deduct.conv</a>]</td> <td>CD2</td> <td>Deduction for <TT>const T&</TT> conversion operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="977"> <td><a href="https://cplusplus.github.io/CWG/issues/977.html">977</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD3</td> <td>When is an enumeration type complete?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="978"> <td><a href="https://cplusplus.github.io/CWG/issues/978.html">978</a></td> + <td>[<a href="https://wg21.link/over.best.ics">over.best.ics</a>]</td> <td>CD2</td> <td>Incorrect specification for copy initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="979"> <td><a href="https://cplusplus.github.io/CWG/issues/979.html">979</a></td> + <td>[<a href="https://wg21.link/dcl.decl">dcl.decl</a>]</td> <td>CD2</td> <td>Position of <I>attribute-specifier</I> in declarator syntax</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="980"> <td><a href="https://cplusplus.github.io/CWG/issues/980.html">980</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>CD2</td> <td>Explicit instantiation of a member of a class template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="981"> <td><a href="https://cplusplus.github.io/CWG/issues/981.html">981</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>C++11</td> <td>Constexpr constructor templates and literal types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="982"> <td><a href="https://cplusplus.github.io/CWG/issues/982.html">982</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>NAD</td> <td>Initialization with an empty initializer list</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="983"> <td><a href="https://cplusplus.github.io/CWG/issues/983.html">983</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>CD2</td> <td>Ambiguous pointer-to-member constant</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="984"> <td><a href="https://cplusplus.github.io/CWG/issues/984.html">984</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD2</td> <td>“Deduced type” is unclear in <TT>auto</TT> type deduction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="985"> <td><a href="https://cplusplus.github.io/CWG/issues/985.html">985</a></td> + <td>[<a href="https://wg21.link/lex.digraph">lex.digraph</a>]</td> <td>C++11</td> <td>Alternative tokens and user-defined literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="986"> <td><a href="https://cplusplus.github.io/CWG/issues/986.html">986</a></td> + <td>[<a href="https://wg21.link/namespace.udir">namespace.udir</a>]</td> <td>CD2</td> <td>Transitivity of <I>using-directive</I>s versus qualified lookup</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="987"> <td><a href="https://cplusplus.github.io/CWG/issues/987.html">987</a></td> + <td>[<a href="https://wg21.link/basic.namespace">basic.namespace</a>]</td> <td>CD4</td> <td>Which declarations introduce namespace members?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="988"> <td><a href="https://cplusplus.github.io/CWG/issues/988.html">988</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>CD2</td> <td>Reference-to-reference collapsing with <TT>decltype</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="989"> <td><a href="https://cplusplus.github.io/CWG/issues/989.html">989</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD2</td> <td>Misplaced list-initialization example</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="990"> <td><a href="https://cplusplus.github.io/CWG/issues/990.html">990</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD2</td> <td>Value initialization with multiple initializer-list constructors</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="991"> <td><a href="https://cplusplus.github.io/CWG/issues/991.html">991</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD2</td> <td>Reference parameters of constexpr functions and constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="992"> <td><a href="https://cplusplus.github.io/CWG/issues/992.html">992</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>NAD</td> <td>Inheriting explicitness</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="993"> <td><a href="https://cplusplus.github.io/CWG/issues/993.html">993</a></td> + <td>[<a href="https://wg21.link/temp.point">temp.point</a>]</td> <td>C++11</td> <td>Freedom to perform instantiation at the end of the translation unit</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="994"> <td><a href="https://cplusplus.github.io/CWG/issues/994.html">994</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>C++11</td> <td><I>braced-init-list</I> as a default argument</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="995"> <td><a href="https://cplusplus.github.io/CWG/issues/995.html">995</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>CD2</td> <td>Incorrect example for <I>using-declaration</I> and explicit instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="996"> <td><a href="https://cplusplus.github.io/CWG/issues/996.html">996</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial">temp.spec.partial</a>]</td> <td>C++11</td> <td>Ambiguous partial specializations of member class templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="997"> <td><a href="https://cplusplus.github.io/CWG/issues/997.html">997</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>C++11</td> <td>Argument-dependent lookup and dependent function template parameter types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="998"> <td><a href="https://cplusplus.github.io/CWG/issues/998.html">998</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>dup</td> <td>Function parameter transformations and template functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="999"> <td><a href="https://cplusplus.github.io/CWG/issues/999.html">999</a></td> + <td>[<a href="https://wg21.link/over.match">over.match</a>]</td> <td>CD2</td> <td>“Implicit” or “implied” object argument/parameter?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1000"> <td><a href="https://cplusplus.github.io/CWG/issues/1000.html">1000</a></td> + <td>[<a href="https://wg21.link/class.qual">class.qual</a>]</td> <td>CD2</td> <td>Mistaking member typedefs for constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1001"> <td><a href="https://cplusplus.github.io/CWG/issues/1001.html">1001</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>review</td> <td>Parameter type adjustment in dependent parameter types</td> <td align="center">Not resolved</td> </tr> <tr id="1002"> <td><a href="https://cplusplus.github.io/CWG/issues/1002.html">1002</a></td> + <td>[<a href="https://wg21.link/temp.variadic">temp.variadic</a>]</td> <td>NAD</td> <td>Pack expansion for function arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1003"> <td><a href="https://cplusplus.github.io/CWG/issues/1003.html">1003</a></td> + <td>[<a href="https://wg21.link/basic.start.main">basic.start.main</a>]</td> <td>CD3</td> <td>Acceptable definitions of <TT>main</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1004"> <td><a href="https://cplusplus.github.io/CWG/issues/1004.html">1004</a></td> + <td>[<a href="https://wg21.link/temp.local">temp.local</a>]</td> <td>C++11</td> <td>Injected-class-names as arguments for template template parameters</td> <td class="full" align="center">Clang 5</td> </tr> <tr id="1005"> <td><a href="https://cplusplus.github.io/CWG/issues/1005.html">1005</a></td> + <td>[<a href="https://wg21.link/class.mfct.non.static">class.mfct.non.static</a>]</td> <td>NAD</td> <td>Qualified name resolution in member functions of class templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1006"> <td><a href="https://cplusplus.github.io/CWG/issues/1006.html">1006</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>C++11</td> <td><TT>std::nullptr_t</TT> as a non-type template parameter</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1007"> <td><a href="https://cplusplus.github.io/CWG/issues/1007.html">1007</a></td> + <td>[<a href="https://wg21.link/class.protected">class.protected</a>]</td> <td>NAD</td> <td>Protected access and pointers to members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1008"> <td><a href="https://cplusplus.github.io/CWG/issues/1008.html">1008</a></td> + <td>[<a href="https://wg21.link/expr.alignof">expr.alignof</a>]</td> <td>NAD</td> <td>Querying the alignment of an object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1009"> <td><a href="https://cplusplus.github.io/CWG/issues/1009.html">1009</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>C++11</td> <td>Missing cases in the <I>declarator-id</I> of a function template declaration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1010"> <td><a href="https://cplusplus.github.io/CWG/issues/1010.html">1010</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD2</td> <td>Address of object with dynamic storage duration in constant expression</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1011"> <td><a href="https://cplusplus.github.io/CWG/issues/1011.html">1011</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>C++11</td> <td>Standard conversions that cannot be inverted</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1012"> <td><a href="https://cplusplus.github.io/CWG/issues/1012.html">1012</a></td> + <td>[<a href="https://wg21.link/namespace.unnamed">namespace.unnamed</a>]</td> <td>C++11</td> <td>Undeprecating <TT>static</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1013"> <td><a href="https://cplusplus.github.io/CWG/issues/1013.html">1013</a></td> + <td>[<a href="https://wg21.link/conv.lval">conv.lval</a>]</td> <td>CD3</td> <td>Uninitialized <TT>std::nullptr_t</TT> objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1014"> <td><a href="https://cplusplus.github.io/CWG/issues/1014.html">1014</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>NAD</td> <td>Overload resolution between <TT>const T&</TT> and <TT>T&&</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1015"> <td><a href="https://cplusplus.github.io/CWG/issues/1015.html">1015</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>C++11</td> <td>Template arguments and argument-dependent lookup</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1016"> <td><a href="https://cplusplus.github.io/CWG/issues/1016.html">1016</a></td> + <td>[<a href="https://wg21.link/over">over</a>]</td> <td>C++11</td> <td>Overloadable declarations, function templates, and references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1017"> <td><a href="https://cplusplus.github.io/CWG/issues/1017.html">1017</a></td> + <td>[<a href="https://wg21.link/class.mfct.non.static">class.mfct.non.static</a>]</td> <td>C++11</td> <td>Member access transformation in unevaluated operands</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1018"> <td><a href="https://cplusplus.github.io/CWG/issues/1018.html">1018</a></td> + <td>[<a href="https://wg21.link/dcl.pre">dcl.pre</a>]</td> <td>C++11</td> <td>Ambiguity between <I>simple-declaration</I> and <I>attribute-declaration</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1019"> <td><a href="https://cplusplus.github.io/CWG/issues/1019.html">1019</a></td> + <td>[<a href="https://wg21.link/class.derived">class.derived</a>]</td> <td>dup</td> <td>Dependent <I>simple-template-id</I>s in <I>base-specifier</I>s and <I>mem-initializer</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1020"> <td><a href="https://cplusplus.github.io/CWG/issues/1020.html">1020</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++11</td> <td>Implicitly-defined copy constructors and explicit base class constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1021"> <td><a href="https://cplusplus.github.io/CWG/issues/1021.html">1021</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>CD4</td> <td>Definitions of namespace members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1022"> <td><a href="https://cplusplus.github.io/CWG/issues/1022.html">1022</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>C++11</td> <td>Can an enumeration variable have values outside the values of the enumeration?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1023"> <td><a href="https://cplusplus.github.io/CWG/issues/1023.html">1023</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>dup</td> <td><TT>thread_local</TT> objects as non-type template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1024"> <td><a href="https://cplusplus.github.io/CWG/issues/1024.html">1024</a></td> + <td>[<a href="https://wg21.link/lex.ccon">lex.ccon</a>]</td> <td>CD3</td> <td>Limits on multicharacter literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1025"> <td><a href="https://cplusplus.github.io/CWG/issues/1025.html">1025</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>C++11</td> <td>Use of a reference as a non-type template argument</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1026"> <td><a href="https://cplusplus.github.io/CWG/issues/1026.html">1026</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>NAD</td> <td>Cv-qualified non-class rvalues</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1027"> <td><a href="https://cplusplus.github.io/CWG/issues/1027.html">1027</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>review</td> <td>Type consistency and reallocation of scalar types</td> <td align="center">Not resolved</td> </tr> <tr id="1028"> <td><a href="https://cplusplus.github.io/CWG/issues/1028.html">1028</a></td> + <td>[<a href="https://wg21.link/temp.dep.res">temp.dep.res</a>]</td> <td>CD6</td> <td>Dependent names in non-defining declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1029"> <td><a href="https://cplusplus.github.io/CWG/issues/1029.html">1029</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>C++11</td> <td>Type of a destructor call</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1030"> <td><a href="https://cplusplus.github.io/CWG/issues/1030.html">1030</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>C++11</td> <td>Evaluation order in <I>initializer-list</I>s used in aggregate initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1031"> <td><a href="https://cplusplus.github.io/CWG/issues/1031.html">1031</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>C++11</td> <td>Optional elements in attributes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1032"> <td><a href="https://cplusplus.github.io/CWG/issues/1032.html">1032</a></td> + <td>[<a href="https://wg21.link/temp.variadic">temp.variadic</a>]</td> <td>C++11</td> <td>Empty pack expansions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1033"> <td><a href="https://cplusplus.github.io/CWG/issues/1033.html">1033</a></td> + <td>[<a href="https://wg21.link/dcl.align">dcl.align</a>]</td> <td>C++11</td> <td>Restrictions on alignment attributes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1034"> <td><a href="https://cplusplus.github.io/CWG/issues/1034.html">1034</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>C++11</td> <td>Attributes for <TT>return</TT> statements in lambdas</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1035"> <td><a href="https://cplusplus.github.io/CWG/issues/1035.html">1035</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>C++11</td> <td>Omitted and required <I>decl-specifier</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1036"> <td><a href="https://cplusplus.github.io/CWG/issues/1036.html">1036</a></td> + <td>[<a href="https://wg21.link/dcl.align">dcl.align</a>]</td> <td>C++11</td> <td>Alignment attribute in an <I>exception-declaration</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1037"> <td><a href="https://cplusplus.github.io/CWG/issues/1037.html">1037</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>C++11</td> <td>Requirements for operands of <I>delete-expression</I>s and deallocation functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1038"> <td><a href="https://cplusplus.github.io/CWG/issues/1038.html">1038</a></td> + <td>[<a href="https://wg21.link/over.over">over.over</a>]</td> <td>CD7</td> <td>Overload resolution of <TT>&x.static_func</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1039"> <td><a href="https://cplusplus.github.io/CWG/issues/1039.html">1039</a></td> + <td>[<a href="https://wg21.link/dcl.align">dcl.align</a>]</td> <td>dup</td> <td>Coordinating C and C++ alignment specifications</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1040"> <td><a href="https://cplusplus.github.io/CWG/issues/1040.html">1040</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>NAD</td> <td>Memory model issues</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1041"> <td><a href="https://cplusplus.github.io/CWG/issues/1041.html">1041</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>dup</td> <td><I>alias-declaration</I>s as class members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1042"> <td><a href="https://cplusplus.github.io/CWG/issues/1042.html">1042</a></td> + <td>[<a href="https://wg21.link/dcl.pre">dcl.pre</a>]</td> <td>C++11</td> <td>Attributes in <I>alias-declaration</I>s</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="1043"> <td><a href="https://cplusplus.github.io/CWG/issues/1043.html">1043</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>C++11</td> <td>Qualified name lookup in the current instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1044"> <td><a href="https://cplusplus.github.io/CWG/issues/1044.html">1044</a></td> + <td>[<a href="https://wg21.link/basic.scope.pdecl">basic.scope.pdecl</a>]</td> <td>C++11</td> <td>Point of declaration for an <I>alias-declaration</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1045"> <td><a href="https://cplusplus.github.io/CWG/issues/1045.html">1045</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>NAD</td> <td>Requiring explicit instantiation declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1046"> <td><a href="https://cplusplus.github.io/CWG/issues/1046.html">1046</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>open</td> <td>What is a “use” of a class specialization?</td> <td align="center">Not resolved</td> </tr> <tr id="1047"> <td><a href="https://cplusplus.github.io/CWG/issues/1047.html">1047</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>C++11</td> <td>When is <TT>typeid</TT> value-dependent?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1048"> <td><a href="https://cplusplus.github.io/CWG/issues/1048.html">1048</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD3</td> <td><TT>auto</TT> deduction and lambda return type deduction.</td> <td class="full" align="center">Clang 3.6</td> </tr> <tr class="open" id="1049"> <td><a href="https://cplusplus.github.io/CWG/issues/1049.html">1049</a></td> + <td>[<a href="https://wg21.link/class.copy.elision">class.copy.elision</a>]</td> <td>open</td> <td>Copy elision through reference parameters of inline functions</td> <td align="center">Not resolved</td> </tr> <tr id="1050"> <td><a href="https://cplusplus.github.io/CWG/issues/1050.html">1050</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>NAD</td> <td>Effects of thread support on object lifetime</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1051"> <td><a href="https://cplusplus.github.io/CWG/issues/1051.html">1051</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++11</td> <td>Reference members and generated copy constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1052"> <td><a href="https://cplusplus.github.io/CWG/issues/1052.html">1052</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>dup</td> <td><TT>const</TT> non-static data member and PODness</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1053"> <td><a href="https://cplusplus.github.io/CWG/issues/1053.html">1053</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>NAD</td> <td>Terminate vs undefined behavior for noexcept violation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1054"> <td><a href="https://cplusplus.github.io/CWG/issues/1054.html">1054</a></td> + <td>[<a href="https://wg21.link/stmt.expr">stmt.expr</a>]</td> <td>C++11</td> <td>Lvalue-to-rvalue conversions in expression statements</td> <td class="none" align="center">No</td> </tr> <tr id="1055"> <td><a href="https://cplusplus.github.io/CWG/issues/1055.html">1055</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>C++11</td> <td>Permissible uses of <TT>void</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1056"> <td><a href="https://cplusplus.github.io/CWG/issues/1056.html">1056</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>C++11</td> <td>Template aliases, member definitions, and the current instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1057"> <td><a href="https://cplusplus.github.io/CWG/issues/1057.html">1057</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>C++11</td> <td><TT>decltype</TT> and the current instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1058"> <td><a href="https://cplusplus.github.io/CWG/issues/1058.html">1058</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>NAD</td> <td>Reference binding of incompatible array types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1059"> <td><a href="https://cplusplus.github.io/CWG/issues/1059.html">1059</a></td> + <td>[<a href="https://wg21.link/basic.type.qualifier">basic.type.qualifier</a>]</td> <td>CD3</td> <td>Cv-qualified array types (with rvalues)</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1060"> <td><a href="https://cplusplus.github.io/CWG/issues/1060.html">1060</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++11</td> <td>Scoped enumerators in integral constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1061"> <td><a href="https://cplusplus.github.io/CWG/issues/1061.html">1061</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>C++11</td> <td>Negative array bounds in a <I>new-expression</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1062"> <td><a href="https://cplusplus.github.io/CWG/issues/1062.html">1062</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>C++11</td> <td>Syntax of <I>attribute-specifier</I>s in lambdas</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1063"> <td><a href="https://cplusplus.github.io/CWG/issues/1063.html">1063</a></td> + <td>[<a href="https://wg21.link/dcl.attr.override">dcl.attr.override</a>]</td> <td>C++11</td> <td><TT>[[hiding]]</TT> with non-attribute declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1064"> <td><a href="https://cplusplus.github.io/CWG/issues/1064.html">1064</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++11</td> <td>Defaulted move constructor for a union</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1065"> <td><a href="https://cplusplus.github.io/CWG/issues/1065.html">1065</a></td> + <td>[<a href="https://wg21.link/dcl.attr.override">dcl.attr.override</a>]</td> <td>C++11</td> <td><TT>[[hiding]]</TT> with <TT>[[override]]</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1066"> <td><a href="https://cplusplus.github.io/CWG/issues/1066.html">1066</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>C++11</td> <td>When is a copy/move assignment operator implicitly defined?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1067"> <td><a href="https://cplusplus.github.io/CWG/issues/1067.html">1067</a></td> + <td>[<a href="https://wg21.link/dcl.attr.override">dcl.attr.override</a>]</td> <td>NAD</td> <td><TT>[[hiding]]</TT>, <I>using-declaration</I>s, and multiple inheritance</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1068"> <td><a href="https://cplusplus.github.io/CWG/issues/1068.html">1068</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>C++11</td> <td>Template aliases with default arguments and template parameter packs</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1069"> <td><a href="https://cplusplus.github.io/CWG/issues/1069.html">1069</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>C++11</td> <td>Incorrect function type with <I>trailing-return-type</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1070"> <td><a href="https://cplusplus.github.io/CWG/issues/1070.html">1070</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>C++11</td> <td>Missing initializer clauses in aggregate initialization</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="1071"> <td><a href="https://cplusplus.github.io/CWG/issues/1071.html">1071</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>C++11</td> <td>Literal class types and trivial default constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1072"> <td><a href="https://cplusplus.github.io/CWG/issues/1072.html">1072</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>C++11</td> <td>Scoped enumerator with the same name as its containing class</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1073"> <td><a href="https://cplusplus.github.io/CWG/issues/1073.html">1073</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>C++11</td> <td>Merging <I>dynamic-exception-specification</I>s and <I>noexcept-specification</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1074"> <td><a href="https://cplusplus.github.io/CWG/issues/1074.html">1074</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>C++11</td> <td>Value-dependent <I>noexcept-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1075"> <td><a href="https://cplusplus.github.io/CWG/issues/1075.html">1075</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>C++11</td> <td>Grammar does not allow template alias in <I>type-name</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1076"> <td><a href="https://cplusplus.github.io/CWG/issues/1076.html">1076</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>CD5</td> <td>Value categories and lvalue temporaries</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1077"> <td><a href="https://cplusplus.github.io/CWG/issues/1077.html">1077</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>NAD</td> <td>Explicit specializations in non-containing namespaces</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1078"> <td><a href="https://cplusplus.github.io/CWG/issues/1078.html">1078</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>NAD</td> <td>Narrowing and the usual arithmetic conversions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1079"> <td><a href="https://cplusplus.github.io/CWG/issues/1079.html">1079</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>C++11</td> <td>Overload resolution involving aggregate initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1080"> <td><a href="https://cplusplus.github.io/CWG/issues/1080.html">1080</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++11</td> <td>Confusing relationship between templates and copy constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1081"> <td><a href="https://cplusplus.github.io/CWG/issues/1081.html">1081</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>C++11</td> <td>Defaulted destructor and unusable operator delete</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1082"> <td><a href="https://cplusplus.github.io/CWG/issues/1082.html">1082</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++11</td> <td>Implicit copy function if subobject has none?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1083"> <td><a href="https://cplusplus.github.io/CWG/issues/1083.html">1083</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>C++11</td> <td>Passing an object to ellipsis with non-trivial move constructor</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1084"> <td><a href="https://cplusplus.github.io/CWG/issues/1084.html">1084</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>NAD</td> <td>Conditions for a deleted move function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1085"> <td><a href="https://cplusplus.github.io/CWG/issues/1085.html">1085</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>NAD</td> <td>Move assignment operators and virtual bases</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1086"> <td><a href="https://cplusplus.github.io/CWG/issues/1086.html">1086</a></td> + <td>[<a href="https://wg21.link/expr.const.cast">expr.const.cast</a>]</td> <td>C++11</td> <td><TT>const_cast</TT> to rvalue reference to function type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1087"> <td><a href="https://cplusplus.github.io/CWG/issues/1087.html">1087</a></td> + <td>[<a href="https://wg21.link/over.match.copy">over.match.copy</a>]</td> <td>C++11</td> <td>Additional applications of issue 899</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1088"> <td><a href="https://cplusplus.github.io/CWG/issues/1088.html">1088</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>C++11</td> <td>Dependent non-type template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1089"> <td><a href="https://cplusplus.github.io/CWG/issues/1089.html">1089</a></td> + <td>[<a href="https://wg21.link/basic.lookup.qual.general">basic.lookup.qual.general</a>]</td> <td>open</td> <td>Template parameters in member selections</td> <td align="center">Not resolved</td> </tr> <tr id="1090"> <td><a href="https://cplusplus.github.io/CWG/issues/1090.html">1090</a></td> + <td>[<a href="https://wg21.link/basic.align">basic.align</a>]</td> <td>C++11</td> <td>Alignment of subobjects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1091"> <td><a href="https://cplusplus.github.io/CWG/issues/1091.html">1091</a></td> + <td>[<a href="https://wg21.link/expr.mptr.oper">expr.mptr.oper</a>]</td> <td>C++11</td> <td>Inconsistent use of the term “object expression”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1092"> <td><a href="https://cplusplus.github.io/CWG/issues/1092.html">1092</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>drafting</td> <td>Cycles in overload resolution during instantiation</td> <td align="center">Not resolved</td> </tr> <tr id="1093"> <td><a href="https://cplusplus.github.io/CWG/issues/1093.html">1093</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD3</td> <td>Value-initializing non-objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1094"> <td><a href="https://cplusplus.github.io/CWG/issues/1094.html">1094</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>C++11</td> <td>Converting floating-point values to scoped enumeration types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1095"> <td><a href="https://cplusplus.github.io/CWG/issues/1095.html">1095</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>C++11</td> <td>List-initialization of references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1096"> <td><a href="https://cplusplus.github.io/CWG/issues/1096.html">1096</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>C++11</td> <td>Missing requirement for template definitions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1097"> <td><a href="https://cplusplus.github.io/CWG/issues/1097.html">1097</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>NAD</td> <td>Aggregate initialization of function parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1098"> <td><a href="https://cplusplus.github.io/CWG/issues/1098.html">1098</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++11</td> <td>Pointer conversions in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1099"> <td><a href="https://cplusplus.github.io/CWG/issues/1099.html">1099</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++11</td> <td>Infinite recursion in <TT>constexpr</TT> functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1100"> <td><a href="https://cplusplus.github.io/CWG/issues/1100.html">1100</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++11</td> <td><TT>constexpr</TT> conversion functions and non-type template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1101"> <td><a href="https://cplusplus.github.io/CWG/issues/1101.html">1101</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>C++11</td> <td>Non-integral initialized static data members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1102"> <td><a href="https://cplusplus.github.io/CWG/issues/1102.html">1102</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>C++11</td> <td>Better example of undefined behavior</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1103"> <td><a href="https://cplusplus.github.io/CWG/issues/1103.html">1103</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>C++11</td> <td>Reversion of phase 1 and 2 transformations in raw string literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1104"> <td><a href="https://cplusplus.github.io/CWG/issues/1104.html">1104</a></td> + <td>[<a href="https://wg21.link/lex.digraph">lex.digraph</a>]</td> <td>C++11</td> <td>Global-scope template arguments vs the <TT><:</TT> digraph</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1105"> <td><a href="https://cplusplus.github.io/CWG/issues/1105.html">1105</a></td> + <td>[<a href="https://wg21.link/lex.name">lex.name</a>]</td> <td>C++11</td> <td>Issues relating to TR 10176:2003</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1106"> <td><a href="https://cplusplus.github.io/CWG/issues/1106.html">1106</a></td> + <td>[<a href="https://wg21.link/lex.nullptr">lex.nullptr</a>]</td> <td>C++11</td> <td>Need more detail in <TT>nullptr</TT> keyword description</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1107"> <td><a href="https://cplusplus.github.io/CWG/issues/1107.html">1107</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>C++11</td> <td>Overload resolution for user-defined integer literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1108"> <td><a href="https://cplusplus.github.io/CWG/issues/1108.html">1108</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>NAD</td> <td>User-defined literals have not been implemented</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1109"> <td><a href="https://cplusplus.github.io/CWG/issues/1109.html">1109</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>C++11</td> <td>When is “use” a reference to the ODR meaning?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1110"> <td><a href="https://cplusplus.github.io/CWG/issues/1110.html">1110</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>NAD</td> <td>Incomplete return type should be allowed in <TT>decltype</TT> operand</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="1111"> <td><a href="https://cplusplus.github.io/CWG/issues/1111.html">1111</a></td> + <td>[<a href="https://wg21.link/basic.lookup.classref">basic.lookup.classref</a>]</td> <td>C++11</td> <td>Remove dual-scope lookup of member template names</td> <td class="partial" align="center">Partial</td> </tr> <tr id="1112"> <td><a href="https://cplusplus.github.io/CWG/issues/1112.html">1112</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>C++11</td> <td><TT>constexpr</TT> variables should have internal linkage like <TT>const</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1113"> <td><a href="https://cplusplus.github.io/CWG/issues/1113.html">1113</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>C++11</td> <td>Linkage of namespace member of unnamed namespace</td> <td class="partial" align="center">Partial</td> </tr> <tr id="1114"> <td><a href="https://cplusplus.github.io/CWG/issues/1114.html">1114</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>C++11</td> <td>Incorrect use of placement <TT>new</TT> in example</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1115"> <td><a href="https://cplusplus.github.io/CWG/issues/1115.html">1115</a></td> + <td>[<a href="https://wg21.link/basic.align">basic.align</a>]</td> <td>C++11</td> <td>C-compatible alignment specification</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1116"> <td><a href="https://cplusplus.github.io/CWG/issues/1116.html">1116</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD4</td> <td>Aliasing of union members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1117"> <td><a href="https://cplusplus.github.io/CWG/issues/1117.html">1117</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>C++11</td> <td>Incorrect note about xvalue member access expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1118"> <td><a href="https://cplusplus.github.io/CWG/issues/1118.html">1118</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>NAD</td> <td>Implicit lambda capture via explicit copy constructor</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1119"> <td><a href="https://cplusplus.github.io/CWG/issues/1119.html">1119</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>C++11</td> <td>Missing case in description of member access ambiguity</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1120"> <td><a href="https://cplusplus.github.io/CWG/issues/1120.html">1120</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>C++11</td> <td><TT>reinterpret_cast</TT> and <TT>void*</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1121"> <td><a href="https://cplusplus.github.io/CWG/issues/1121.html">1121</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>C++11</td> <td>Unnecessary ambiguity error in formation of pointer to member</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1122"> <td><a href="https://cplusplus.github.io/CWG/issues/1122.html">1122</a></td> + <td>[<a href="https://wg21.link/expr.sizeof">expr.sizeof</a>]</td> <td>C++11</td> <td>Circular definition of <TT>std::size_t</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1123"> <td><a href="https://cplusplus.github.io/CWG/issues/1123.html">1123</a></td> + <td>[<a href="https://wg21.link/expr.unary.noexcept">expr.unary.noexcept</a>]</td> <td>C++11</td> <td>Destructors should be <TT>noexcept</TT> by default</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1124"> <td><a href="https://cplusplus.github.io/CWG/issues/1124.html">1124</a></td> + <td>[<a href="https://wg21.link/expr.mptr.oper">expr.mptr.oper</a>]</td> <td>NAD</td> <td>Error in description of value category of pointer-to-member expression</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1125"> <td><a href="https://cplusplus.github.io/CWG/issues/1125.html">1125</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++11</td> <td>Unclear definition of “potential constant expression”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1126"> <td><a href="https://cplusplus.github.io/CWG/issues/1126.html">1126</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++11</td> <td><TT>constexpr</TT> functions in <TT>const</TT> initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1127"> <td><a href="https://cplusplus.github.io/CWG/issues/1127.html">1127</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++11</td> <td>Overload resolution in <TT>constexpr</TT> functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1128"> <td><a href="https://cplusplus.github.io/CWG/issues/1128.html">1128</a></td> + <td>[<a href="https://wg21.link/dcl.spec">dcl.spec</a>]</td> <td>C++11</td> <td><I>attribute-specifier</I>s in <I>decl-specifier-seq</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1129"> <td><a href="https://cplusplus.github.io/CWG/issues/1129.html">1129</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++11</td> <td>Default <TT>nothrow</TT> for <TT>constexpr</TT> functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1130"> <td><a href="https://cplusplus.github.io/CWG/issues/1130.html">1130</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>C++11</td> <td>Function parameter type adjustments and <TT>decltype</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1131"> <td><a href="https://cplusplus.github.io/CWG/issues/1131.html">1131</a></td> + <td>[<a href="https://wg21.link/dcl.type.elab">dcl.type.elab</a>]</td> <td>C++11</td> <td>Template aliases in <I>elaborated-type-specifier</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1132"> <td><a href="https://cplusplus.github.io/CWG/issues/1132.html">1132</a></td> + <td>[<a href="https://wg21.link/dcl.attr.noreturn">dcl.attr.noreturn</a>]</td> <td>NAD</td> <td>Keyword vs attribute for <TT>noreturn</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1133"> <td><a href="https://cplusplus.github.io/CWG/issues/1133.html">1133</a></td> + <td>[<a href="https://wg21.link/dcl.attr.override">dcl.attr.override</a>]</td> <td>C++11</td> <td>Keywords vs attributes for control of hiding and overriding</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1134"> <td><a href="https://cplusplus.github.io/CWG/issues/1134.html">1134</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>C++11</td> <td>When is an explicitly-defaulted function defined?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1135"> <td><a href="https://cplusplus.github.io/CWG/issues/1135.html">1135</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>C++11</td> <td>Explicitly-defaulted non-public special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1136"> <td><a href="https://cplusplus.github.io/CWG/issues/1136.html">1136</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>C++11</td> <td>Explicitly-defaulted explicit constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1137"> <td><a href="https://cplusplus.github.io/CWG/issues/1137.html">1137</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>C++11</td> <td>Explicitly-defaulted virtual special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1138"> <td><a href="https://cplusplus.github.io/CWG/issues/1138.html">1138</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>C++11</td> <td>Rvalue-ness check for rvalue reference binding is wrong</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1139"> <td><a href="https://cplusplus.github.io/CWG/issues/1139.html">1139</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>C++11</td> <td>Rvalue reference binding to scalar xvalues</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1140"> <td><a href="https://cplusplus.github.io/CWG/issues/1140.html">1140</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>C++11</td> <td>Incorrect redefinition of POD class</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1141"> <td><a href="https://cplusplus.github.io/CWG/issues/1141.html">1141</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>NAD</td> <td>Non-static data member initializers have not been implemented</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1142"> <td><a href="https://cplusplus.github.io/CWG/issues/1142.html">1142</a></td> + <td>[<a href="https://wg21.link/class.mfct">class.mfct</a>]</td> <td>C++11</td> <td><TT>friend</TT> declaration of member function of containing class</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1143"> <td><a href="https://cplusplus.github.io/CWG/issues/1143.html">1143</a></td> + <td>[<a href="https://wg21.link/class.mfct.non.static">class.mfct.non.static</a>]</td> <td>NAD</td> <td>Move semantics for <TT>*this</TT> have not been implemented</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1144"> <td><a href="https://cplusplus.github.io/CWG/issues/1144.html">1144</a></td> + <td>[<a href="https://wg21.link/class.access.dcl">class.access.dcl</a>]</td> <td>C++11</td> <td>Remove access declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1145"> <td><a href="https://cplusplus.github.io/CWG/issues/1145.html">1145</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>C++11</td> <td>Defaulting and triviality</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1146"> <td><a href="https://cplusplus.github.io/CWG/issues/1146.html">1146</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>C++11</td> <td><I>exception-specification</I>s of defaulted functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1147"> <td><a href="https://cplusplus.github.io/CWG/issues/1147.html">1147</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>C++11</td> <td>Destructors should be default <TT>nothrow</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1148"> <td><a href="https://cplusplus.github.io/CWG/issues/1148.html">1148</a></td> + <td>[<a href="https://wg21.link/class.copy.elision">class.copy.elision</a>]</td> <td>C++11</td> <td>Copy elision and move construction of function parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1149"> <td><a href="https://cplusplus.github.io/CWG/issues/1149.html">1149</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++11</td> <td>Trivial non-public copy operators in subobjects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1150"> <td><a href="https://cplusplus.github.io/CWG/issues/1150.html">1150</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>NAD</td> <td>Inheriting constructors have not been implemented</td> <td class="na" align="center">N/A</td> </tr> <tr id="1151"> <td><a href="https://cplusplus.github.io/CWG/issues/1151.html">1151</a></td> + <td>[<a href="https://wg21.link/over.match.list">over.match.list</a>]</td> <td>C++11</td> <td>Overload resolution with initializer-list and non-list constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1152"> <td><a href="https://cplusplus.github.io/CWG/issues/1152.html">1152</a></td> + <td>[<a href="https://wg21.link/over.match.viable">over.match.viable</a>]</td> <td>C++11</td> <td>Rules for determining existence of implicit conversion sequence</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1153"> <td><a href="https://cplusplus.github.io/CWG/issues/1153.html">1153</a></td> + <td>[<a href="https://wg21.link/over.over">over.over</a>]</td> <td>C++11</td> <td>Type matching in address of overloaded function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1154"> <td><a href="https://cplusplus.github.io/CWG/issues/1154.html">1154</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>C++11</td> <td>Address of <TT>thread_local</TT> variable as non-type template argument</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1155"> <td><a href="https://cplusplus.github.io/CWG/issues/1155.html">1155</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>C++11</td> <td>Internal-linkage non-type template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1156"> <td><a href="https://cplusplus.github.io/CWG/issues/1156.html">1156</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>C++11</td> <td>Partial ordering in a non-call context</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1157"> <td><a href="https://cplusplus.github.io/CWG/issues/1157.html">1157</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>open</td> <td>Partial ordering of function templates is still underspecified</td> <td align="center">Not resolved</td> </tr> <tr id="1158"> <td><a href="https://cplusplus.github.io/CWG/issues/1158.html">1158</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>C++11</td> <td>Recursive instantiation via alias template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1159"> <td><a href="https://cplusplus.github.io/CWG/issues/1159.html">1159</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>C++11</td> <td>Class and enumeration definitions in template aliases</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1160"> <td><a href="https://cplusplus.github.io/CWG/issues/1160.html">1160</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>C++11</td> <td>Definitions of template members and the current instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1161"> <td><a href="https://cplusplus.github.io/CWG/issues/1161.html">1161</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>C++11</td> <td>Dependent <I>nested-name-specifier</I> in a pointer-to-member declarator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1162"> <td><a href="https://cplusplus.github.io/CWG/issues/1162.html">1162</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>NAD</td> <td>Dependent <I>elaborated-type-specifier</I>s in non-deduced contexts</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1163"> <td><a href="https://cplusplus.github.io/CWG/issues/1163.html">1163</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>NAD</td> <td><TT>extern template</TT> prevents inlining functions not marked <TT>inline</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1164"> <td><a href="https://cplusplus.github.io/CWG/issues/1164.html">1164</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>C++11</td> <td>Partial ordering of <TT>f(T&)</TT> and <TT>f(T&&)</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1165"> <td><a href="https://cplusplus.github.io/CWG/issues/1165.html">1165</a></td> + <td>[<a href="https://wg21.link/except.ctor">except.ctor</a>]</td> <td>C++11</td> <td>Exceptions when destroying array elements</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1166"> <td><a href="https://cplusplus.github.io/CWG/issues/1166.html">1166</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>C++11</td> <td><I>exception-declaration</I>s that do not declare objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1167"> <td><a href="https://cplusplus.github.io/CWG/issues/1167.html">1167</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>C++11</td> <td><I>function-try-block</I>s for destructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1168"> <td><a href="https://cplusplus.github.io/CWG/issues/1168.html">1168</a></td> + <td>[<a href="https://wg21.link/except.terminate">except.terminate</a>]</td> <td>C++11</td> <td>Additional reasons to call <TT>std::terminate</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1169"> <td><a href="https://cplusplus.github.io/CWG/issues/1169.html">1169</a></td> + <td>[<a href="https://wg21.link/cpp.predefined">cpp.predefined</a>]</td> <td>C++11</td> <td>Missing feature macro for strict pointer safety</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1170"> <td><a href="https://cplusplus.github.io/CWG/issues/1170.html">1170</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>C++11</td> <td>Access checking during template argument deduction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1171"> <td><a href="https://cplusplus.github.io/CWG/issues/1171.html">1171</a></td> + <td>[<a href="https://wg21.link/except.terminate">except.terminate</a>]</td> <td>C++11</td> <td>Partial stack unwinding with <TT>noexcept</TT> violation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1172"> <td><a href="https://cplusplus.github.io/CWG/issues/1172.html">1172</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>drafting</td> <td>“instantiation-dependent” constructs</td> <td align="center">Not resolved</td> </tr> <tr id="1173"> <td><a href="https://cplusplus.github.io/CWG/issues/1173.html">1173</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>C++11</td> <td>Unclear specification of effects of signal handling</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1174"> <td><a href="https://cplusplus.github.io/CWG/issues/1174.html">1174</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>C++11</td> <td>When is a pure virtual function “used?”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1175"> <td><a href="https://cplusplus.github.io/CWG/issues/1175.html">1175</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>C++11</td> <td>Disambiguating user-defined literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1176"> <td><a href="https://cplusplus.github.io/CWG/issues/1176.html">1176</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>C++11</td> <td>Definition of release sequence</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1177"> <td><a href="https://cplusplus.github.io/CWG/issues/1177.html">1177</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>C++11</td> <td>Intra-thread dependency-ordered-before</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1178"> <td><a href="https://cplusplus.github.io/CWG/issues/1178.html">1178</a></td> + <td>[<a href="https://wg21.link/temp.deduct.decl">temp.deduct.decl</a>]</td> <td>C++11</td> <td>Deduction failure matching placement new</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1179"> <td><a href="https://cplusplus.github.io/CWG/issues/1179.html">1179</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>NAD</td> <td>Cv-qualification of non-type template parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1180"> <td><a href="https://cplusplus.github.io/CWG/issues/1180.html">1180</a></td> + <td>[<a href="https://wg21.link/basic.align">basic.align</a>]</td> <td>C++11</td> <td>Over-aligned class types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1181"> <td><a href="https://cplusplus.github.io/CWG/issues/1181.html">1181</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>C++11</td> <td>What is a “built-in type?”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1182"> <td><a href="https://cplusplus.github.io/CWG/issues/1182.html">1182</a></td> + <td>[<a href="https://wg21.link/temp.variadic">temp.variadic</a>]</td> <td>C++11</td> <td>Incorrect description of pack expansion syntax</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1183"> <td><a href="https://cplusplus.github.io/CWG/issues/1183.html">1183</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>C++11</td> <td>Expansion of parameter packs in declarators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1184"> <td><a href="https://cplusplus.github.io/CWG/issues/1184.html">1184</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>C++11</td> <td>Argument conversions to nondeduced parameter types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1185"> <td><a href="https://cplusplus.github.io/CWG/issues/1185.html">1185</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>C++11</td> <td>Misleading description of language linkage and member function types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1186"> <td><a href="https://cplusplus.github.io/CWG/issues/1186.html">1186</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++11</td> <td>Non-dependent <TT>constexpr</TT> violations in function templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1187"> <td><a href="https://cplusplus.github.io/CWG/issues/1187.html">1187</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>C++11</td> <td>Problems in initialization example</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1188"> <td><a href="https://cplusplus.github.io/CWG/issues/1188.html">1188</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++11</td> <td>Type punning in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1189"> <td><a href="https://cplusplus.github.io/CWG/issues/1189.html">1189</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>C++11</td> <td>Address of distinct base class subobjects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1190"> <td><a href="https://cplusplus.github.io/CWG/issues/1190.html">1190</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.safety">basic.stc.dynamic.safety</a>]</td> <td>C++11</td> <td>Operations on non-safely-derived pointers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1191"> <td><a href="https://cplusplus.github.io/CWG/issues/1191.html">1191</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>C++11</td> <td>Deleted subobject destructors and implicitly-defined constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1192"> <td><a href="https://cplusplus.github.io/CWG/issues/1192.html">1192</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>C++11</td> <td>Inadvertent change to ODR and templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1193"> <td><a href="https://cplusplus.github.io/CWG/issues/1193.html">1193</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++11</td> <td>Use of address-constant pointers in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1194"> <td><a href="https://cplusplus.github.io/CWG/issues/1194.html">1194</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++11</td> <td>Constexpr references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1195"> <td><a href="https://cplusplus.github.io/CWG/issues/1195.html">1195</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++11</td> <td>References to non-literal types in constexpr functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1196"> <td><a href="https://cplusplus.github.io/CWG/issues/1196.html">1196</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>C++11</td> <td>Definition required for explicit instantiation after explicit specialization?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1197"> <td><a href="https://cplusplus.github.io/CWG/issues/1197.html">1197</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++11</td> <td>Constexpr arrays</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1198"> <td><a href="https://cplusplus.github.io/CWG/issues/1198.html">1198</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>C++11</td> <td>Literal types and copy constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1199"> <td><a href="https://cplusplus.github.io/CWG/issues/1199.html">1199</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++11</td> <td>Deleted constexpr functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1200"> <td><a href="https://cplusplus.github.io/CWG/issues/1200.html">1200</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>CD6</td> <td>Lookup rules for template parameters</td> <td class="na" align="center">N/A</td> </tr> <tr id="1201"> <td><a href="https://cplusplus.github.io/CWG/issues/1201.html">1201</a></td> + <td>[<a href="https://wg21.link/basic.def">basic.def</a>]</td> <td>C++11</td> <td>Are deleted and defaulted functions definitions?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1202"> <td><a href="https://cplusplus.github.io/CWG/issues/1202.html">1202</a></td> + <td>[<a href="https://wg21.link/class.cdtor">class.cdtor</a>]</td> <td>C++11</td> <td>Calling virtual functions during destruction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1203"> <td><a href="https://cplusplus.github.io/CWG/issues/1203.html">1203</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>dup</td> <td>Misleading note regarding initialized static data members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1204"> <td><a href="https://cplusplus.github.io/CWG/issues/1204.html">1204</a></td> + <td>[<a href="https://wg21.link/stmt.iter">stmt.iter</a>]</td> <td>C++11</td> <td>Specifiers in a <I>for-range-declaration</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1205"> <td><a href="https://cplusplus.github.io/CWG/issues/1205.html">1205</a></td> + <td>[<a href="https://wg21.link/over.ics.ref">over.ics.ref</a>]</td> <td>dup</td> <td>Lvalue reference binding and function viability</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1206"> <td><a href="https://cplusplus.github.io/CWG/issues/1206.html">1206</a></td> + <td>[<a href="https://wg21.link/temp.class">temp.class</a>]</td> <td>C++11</td> <td>Defining opaque enumeration members of class templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1207"> <td><a href="https://cplusplus.github.io/CWG/issues/1207.html">1207</a></td> + <td>[<a href="https://wg21.link/class.mfct.non.static">class.mfct.non.static</a>]</td> <td>C++11</td> <td>Type of class member in <I>trailing-return-type</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1208"> <td><a href="https://cplusplus.github.io/CWG/issues/1208.html">1208</a></td> + <td>[<a href="https://wg21.link/class.mfct.non.static">class.mfct.non.static</a>]</td> <td>C++11</td> <td>Explicit <TT>noexcept</TT> in defaulted definition</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1209"> <td><a href="https://cplusplus.github.io/CWG/issues/1209.html">1209</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>open</td> <td>Is a potentially-evaluated expression in a template definition a “use?”</td> <td align="center">Not resolved</td> </tr> <tr id="1210"> <td><a href="https://cplusplus.github.io/CWG/issues/1210.html">1210</a></td> + <td>[<a href="https://wg21.link/basic.scope.pdecl">basic.scope.pdecl</a>]</td> <td>C++11</td> <td>Injection of <I>elaborated-type-specifier</I> in enumeration scope</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1211"> <td><a href="https://cplusplus.github.io/CWG/issues/1211.html">1211</a></td> + <td>[<a href="https://wg21.link/basic.align">basic.align</a>]</td> <td>open</td> <td>Misaligned lvalues</td> <td align="center">Not resolved</td> </tr> <tr id="1212"> <td><a href="https://cplusplus.github.io/CWG/issues/1212.html">1212</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>C++11</td> <td>Non-function-call xvalues and <TT>decltype</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1213"> <td><a href="https://cplusplus.github.io/CWG/issues/1213.html">1213</a></td> + <td>[<a href="https://wg21.link/expr.sub">expr.sub</a>]</td> <td>CD3</td> <td>Array subscripting and xvalues</td> <td class="full" align="center">Clang 7</td> </tr> <tr id="1214"> <td><a href="https://cplusplus.github.io/CWG/issues/1214.html">1214</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>C++11</td> <td>Kinds of initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1215"> <td><a href="https://cplusplus.github.io/CWG/issues/1215.html">1215</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>C++11</td> <td>Definition of POD struct</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1216"> <td><a href="https://cplusplus.github.io/CWG/issues/1216.html">1216</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>C++11</td> <td>Exceptions “allowed” by a <I>noexcept-specification</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1217"> <td><a href="https://cplusplus.github.io/CWG/issues/1217.html">1217</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.delete">dcl.fct.def.delete</a>]</td> <td>NAD</td> <td>Are deleted functions implicitly <TT>noexcept</TT>?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1218"> <td><a href="https://cplusplus.github.io/CWG/issues/1218.html">1218</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>C++11</td> <td>What is the “currently-handled exception” in a multi-threaded program?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1219"> <td><a href="https://cplusplus.github.io/CWG/issues/1219.html">1219</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>C++11</td> <td>Non-static data member initializers in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1220"> <td><a href="https://cplusplus.github.io/CWG/issues/1220.html">1220</a></td> + <td>[<a href="https://wg21.link/basic.lookup.classref">basic.lookup.classref</a>]</td> <td>C++11</td> <td>Looking up <I>conversion-type-id</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1221"> <td><a href="https://cplusplus.github.io/CWG/issues/1221.html">1221</a></td> + <td>[<a href="https://wg21.link/temp.deduct.partial">temp.deduct.partial</a>]</td> <td>open</td> <td>Partial ordering and reference collapsing</td> <td align="center">Not resolved</td> </tr> <tr id="1222"> <td><a href="https://cplusplus.github.io/CWG/issues/1222.html">1222</a></td> + <td>[<a href="https://wg21.link/dcl.array">dcl.array</a>]</td> <td>NAD</td> <td>Unnecessary restriction on <TT>auto</TT> array types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1223"> <td><a href="https://cplusplus.github.io/CWG/issues/1223.html">1223</a></td> + <td>[<a href="https://wg21.link/stmt.ambig">stmt.ambig</a>]</td> <td>CD7</td> <td>Syntactic disambiguation and <I>trailing-return-type</I>s</td> <td class="full" align="center">Clang 17</td> </tr> <tr id="1224"> <td><a href="https://cplusplus.github.io/CWG/issues/1224.html">1224</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++11</td> <td><TT>constexpr</TT> defaulted copy constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1225"> <td><a href="https://cplusplus.github.io/CWG/issues/1225.html">1225</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++11</td> <td><TT>constexpr</TT> constructors and virtual bases</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1226"> <td><a href="https://cplusplus.github.io/CWG/issues/1226.html">1226</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>CD3</td> <td>Converting a <I>braced-init-list</I> default argument</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1227"> <td><a href="https://cplusplus.github.io/CWG/issues/1227.html">1227</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD3</td> <td>Mixing immediate and non-immediate contexts in deduction failure</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="1228"> <td><a href="https://cplusplus.github.io/CWG/issues/1228.html">1228</a></td> + <td>[<a href="https://wg21.link/over.match.list">over.match.list</a>]</td> <td>NAD</td> <td>Copy-list-initialization and <TT>explicit</TT> constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1229"> <td><a href="https://cplusplus.github.io/CWG/issues/1229.html">1229</a></td> + <td>[<a href="https://wg21.link/over.match.list">over.match.list</a>]</td> <td>C++11</td> <td>Overload resolution with empty <I>braced-init-list</I> argument</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1230"> <td><a href="https://cplusplus.github.io/CWG/issues/1230.html">1230</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>dup</td> <td>Confusing description of ambiguity of destructor name</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1231"> <td><a href="https://cplusplus.github.io/CWG/issues/1231.html">1231</a></td> + <td>[<a href="https://wg21.link/temp.variadic">temp.variadic</a>]</td> <td>C++11</td> <td>Variadic templates requiring an empty pack expansion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1232"> <td><a href="https://cplusplus.github.io/CWG/issues/1232.html">1232</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>C++11</td> <td>Creation of array temporaries using a <I>braced-init-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1233"> <td><a href="https://cplusplus.github.io/CWG/issues/1233.html">1233</a></td> + <td>[<a href="https://wg21.link/temp.dep">temp.dep</a>]</td> <td>C++11</td> <td>Pack expansions and dependent calls</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1234"> <td><a href="https://cplusplus.github.io/CWG/issues/1234.html">1234</a></td> + <td>[<a href="https://wg21.link/dcl.name">dcl.name</a>]</td> <td>C++11</td> <td><I>abstract-declarator</I> does not permit <TT>...</TT> after <I>ptr-operator</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1235"> <td><a href="https://cplusplus.github.io/CWG/issues/1235.html">1235</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>C++11</td> <td>“Unused” ellipsis and default arguments in partial ordering</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1236"> <td><a href="https://cplusplus.github.io/CWG/issues/1236.html">1236</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>C++11</td> <td>Inconsistently-interrelated examples</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1237"> <td><a href="https://cplusplus.github.io/CWG/issues/1237.html">1237</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>C++11</td> <td>Deprecated implicit copy assignment in example</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1238"> <td><a href="https://cplusplus.github.io/CWG/issues/1238.html">1238</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>C++11</td> <td>Overloading ambiguity binding reference to function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1239"> <td><a href="https://cplusplus.github.io/CWG/issues/1239.html">1239</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>C++11</td> <td>Hexadecimal floating-point literals vs user-defined literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1240"> <td><a href="https://cplusplus.github.io/CWG/issues/1240.html">1240</a></td> + <td>[<a href="https://wg21.link/dcl.name">dcl.name</a>]</td> <td>C++11</td> <td><TT>constexpr</TT> defaulted constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1241"> <td><a href="https://cplusplus.github.io/CWG/issues/1241.html">1241</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>C++11</td> <td>Which members does a destructor destroy?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1242"> <td><a href="https://cplusplus.github.io/CWG/issues/1242.html">1242</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>C++11</td> <td>Initializing variant class members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1243"> <td><a href="https://cplusplus.github.io/CWG/issues/1243.html">1243</a></td> + <td>[<a href="https://wg21.link/dcl.decl">dcl.decl</a>]</td> <td>C++11</td> <td>Misleading footnote regarding multiple-declarator declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1244"> <td><a href="https://cplusplus.github.io/CWG/issues/1244.html">1244</a></td> + <td>[<a href="https://wg21.link/temp.type">temp.type</a>]</td> <td>C++11</td> <td>Equivalence of alias templates and class templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1245"> <td><a href="https://cplusplus.github.io/CWG/issues/1245.html">1245</a></td> + <td>[<a href="https://wg21.link/temp.mem.func">temp.mem.func</a>]</td> <td>C++11</td> <td>Matching declarations involving <TT>decltype</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1246"> <td><a href="https://cplusplus.github.io/CWG/issues/1246.html">1246</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>C++11</td> <td>Non-deduced non-final parameter packs</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1247"> <td><a href="https://cplusplus.github.io/CWG/issues/1247.html">1247</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>CD4</td> <td>Restriction on alias name appearing in <I>type-id</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1248"> <td><a href="https://cplusplus.github.io/CWG/issues/1248.html">1248</a></td> + <td>[<a href="https://wg21.link/diff.iso">diff.iso</a>]</td> <td>open</td> <td>Updating Annex C to C99 and C23</td> <td align="center">Not resolved</td> </tr> <tr id="1249"> <td><a href="https://cplusplus.github.io/CWG/issues/1249.html">1249</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD6</td> <td>Cv-qualification of nested lambda capture</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1250"> <td><a href="https://cplusplus.github.io/CWG/issues/1250.html">1250</a></td> + <td>[<a href="https://wg21.link/class.virtual">class.virtual</a>]</td> <td>CD3</td> <td>Cv-qualification of incomplete virtual function return types</td> <td class="full" align="center">Clang 3.9</td> </tr> <tr id="1251"> <td><a href="https://cplusplus.github.io/CWG/issues/1251.html">1251</a></td> + <td>[<a href="https://wg21.link/diff.conv">diff.conv</a>]</td> <td>CD3</td> <td>C compatibility: casting to unqualified <TT>void*</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1252"> <td><a href="https://cplusplus.github.io/CWG/issues/1252.html">1252</a></td> + <td>[<a href="https://wg21.link/over.load">over.load</a>]</td> <td>CD6</td> <td>Overloading member function templates based on dependent return type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1253"> <td><a href="https://cplusplus.github.io/CWG/issues/1253.html">1253</a></td> + <td>[<a href="https://wg21.link/temp.spec">temp.spec</a>]</td> <td>C++17</td> <td>Generic non-template members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1254"> <td><a href="https://cplusplus.github.io/CWG/issues/1254.html">1254</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>NAD</td> <td>odr-use vs template arguments and constexpr functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1255"> <td><a href="https://cplusplus.github.io/CWG/issues/1255.html">1255</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>drafting</td> <td>Definition problems with <TT>constexpr</TT> functions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1256"> <td><a href="https://cplusplus.github.io/CWG/issues/1256.html">1256</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Unevaluated operands are not necessarily constant expressions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1257"> <td><a href="https://cplusplus.github.io/CWG/issues/1257.html">1257</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>open</td> <td>Instantiation via non-dependent references in uninstantiated templates</td> <td align="center">Not resolved</td> </tr> <tr id="1258"> <td><a href="https://cplusplus.github.io/CWG/issues/1258.html">1258</a></td> + <td>[<a href="https://wg21.link/temp.point">temp.point</a>]</td> <td>CD5</td> <td>“Instantiation context” differs from dependent lookup rules</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1259"> <td><a href="https://cplusplus.github.io/CWG/issues/1259.html">1259</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>NAD</td> <td>Deleting a POD via a pointer to base</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1260"> <td><a href="https://cplusplus.github.io/CWG/issues/1260.html">1260</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD3</td> <td>Incorrect use of term “overloaded” in description of odr-use</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1261"> <td><a href="https://cplusplus.github.io/CWG/issues/1261.html">1261</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>CD3</td> <td>Explicit handling of cv-qualification with non-class prvalues</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1262"> <td><a href="https://cplusplus.github.io/CWG/issues/1262.html">1262</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD3</td> <td>Default template arguments and deduction failure</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1263"> <td><a href="https://cplusplus.github.io/CWG/issues/1263.html">1263</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>NAD</td> <td>Mismatch between rvalue reference binding and overload resolution</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1264"> <td><a href="https://cplusplus.github.io/CWG/issues/1264.html">1264</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>Use of <TT>this</TT> in <TT>constexpr</TT> constructor</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1265"> <td><a href="https://cplusplus.github.io/CWG/issues/1265.html">1265</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD3</td> <td>Mixed use of the <TT>auto</TT> specifier</td> <td class="full" align="center">Clang 5</td> </tr> <tr class="open" id="1266"> <td><a href="https://cplusplus.github.io/CWG/issues/1266.html">1266</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>open</td> <td><I>user-defined-integer-literal</I> overflow</td> <td align="center">Not resolved</td> </tr> <tr id="1267"> <td><a href="https://cplusplus.github.io/CWG/issues/1267.html">1267</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD3</td> <td>Rvalue reference types in <I>exception-specification</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1268"> <td><a href="https://cplusplus.github.io/CWG/issues/1268.html">1268</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>CD3</td> <td><TT>reinterpret_cast</TT> of an xvalue operand</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1269"> <td><a href="https://cplusplus.github.io/CWG/issues/1269.html">1269</a></td> + <td>[<a href="https://wg21.link/expr.dynamic.cast">expr.dynamic.cast</a>]</td> <td>CD3</td> <td><TT>dynamic_cast</TT> of an xvalue operand</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1270"> <td><a href="https://cplusplus.github.io/CWG/issues/1270.html">1270</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD3</td> <td>Brace elision in array temporary initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1271"> <td><a href="https://cplusplus.github.io/CWG/issues/1271.html">1271</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>CD5</td> <td>Imprecise wording regarding dependent types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1272"> <td><a href="https://cplusplus.github.io/CWG/issues/1272.html">1272</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>NAD</td> <td>Implicit definition of static data member of const literal type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1273"> <td><a href="https://cplusplus.github.io/CWG/issues/1273.html">1273</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>NAD</td> <td>Accessibility and function signatures</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1274"> <td><a href="https://cplusplus.github.io/CWG/issues/1274.html">1274</a></td> + <td>[<a href="https://wg21.link/stmt.ranged">stmt.ranged</a>]</td> <td>CD4</td> <td>Common nonterminal for <I>expression</I> and <I>braced-init-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1275"> <td><a href="https://cplusplus.github.io/CWG/issues/1275.html">1275</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>CD3</td> <td>Incorrect comment in example of template parameter pack restriction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1276"> <td><a href="https://cplusplus.github.io/CWG/issues/1276.html">1276</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>NAD</td> <td>Reference to <TT>stdint.h</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1277"> <td><a href="https://cplusplus.github.io/CWG/issues/1277.html">1277</a></td> + <td>[<a href="https://wg21.link/cstdint.syn">cstdint.syn</a>]</td> <td>NAD</td> <td>Lax definition of <TT>intmax_t</TT> and <TT>uintmax_t</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1278"> <td><a href="https://cplusplus.github.io/CWG/issues/1278.html">1278</a></td> + <td>[<a href="https://wg21.link/over.call.func">over.call.func</a>]</td> <td>drafting</td> <td>Incorrect treatment of contrived object</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1279"> <td><a href="https://cplusplus.github.io/CWG/issues/1279.html">1279</a></td> + <td>[<a href="https://wg21.link/diff.cpp03">diff.cpp03</a>]</td> <td>open</td> <td>Additional differences between C++ 2003 and C++ 2011</td> <td align="center">Not resolved</td> </tr> <tr id="1280"> <td><a href="https://cplusplus.github.io/CWG/issues/1280.html">1280</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>NAD</td> <td>Object reallocation and reference members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1281"> <td><a href="https://cplusplus.github.io/CWG/issues/1281.html">1281</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>NAD</td> <td>Virtual and dependent base classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1282"> <td><a href="https://cplusplus.github.io/CWG/issues/1282.html">1282</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD3</td> <td>Underspecified destructor <I>exception-specification</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1283"> <td><a href="https://cplusplus.github.io/CWG/issues/1283.html">1283</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>open</td> <td>Static data members of classes with typedef name for linkage purposes</td> <td align="center">Not resolved</td> </tr> <tr id="1284"> <td><a href="https://cplusplus.github.io/CWG/issues/1284.html">1284</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD4</td> <td>Should the lifetime of an array be independent of that of its elements?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1285"> <td><a href="https://cplusplus.github.io/CWG/issues/1285.html">1285</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>NAD</td> <td>Trivial destructors and object lifetime</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1286"> <td><a href="https://cplusplus.github.io/CWG/issues/1286.html">1286</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>open</td> <td>Equivalence of alias templates</td> <td align="center">Not resolved</td> </tr> <tr id="1287"> <td><a href="https://cplusplus.github.io/CWG/issues/1287.html">1287</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>C++14</td> <td>Direct initialization vs “implicit” conversion in reference binding</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1288"> <td><a href="https://cplusplus.github.io/CWG/issues/1288.html">1288</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD3</td> <td>Reference list initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1289"> <td><a href="https://cplusplus.github.io/CWG/issues/1289.html">1289</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>NAD</td> <td>Can an alias template name the current instantiation?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1290"> <td><a href="https://cplusplus.github.io/CWG/issues/1290.html">1290</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD3</td> <td>Lifetime of the underlying array of an <TT>initializer_list</TT> member</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1291"> <td><a href="https://cplusplus.github.io/CWG/issues/1291.html">1291</a></td> + <td>[<a href="https://wg21.link/basic.lookup.classref">basic.lookup.classref</a>]</td> <td>CD6</td> <td>Looking up a <I>conversion-type-id</I></td> <td class="na" align="center">N/A</td> </tr> <tr id="1292"> <td><a href="https://cplusplus.github.io/CWG/issues/1292.html">1292</a></td> + <td>[<a href="https://wg21.link/temp.dep">temp.dep</a>]</td> <td>CD4</td> <td>Dependent calls with <I>braced-init-list</I>s containing a pack expansion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1293"> <td><a href="https://cplusplus.github.io/CWG/issues/1293.html">1293</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>String literals in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1294"> <td><a href="https://cplusplus.github.io/CWG/issues/1294.html">1294</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>open</td> <td>Side effects in dynamic/static initialization</td> <td align="center">Not resolved</td> </tr> <tr id="1295"> <td><a href="https://cplusplus.github.io/CWG/issues/1295.html">1295</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD3</td> <td>Binding a reference to an rvalue bit-field</td> <td class="full" align="center">Clang 4</td> </tr> <tr id="1296"> <td><a href="https://cplusplus.github.io/CWG/issues/1296.html">1296</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>CD3</td> <td>Ill-formed template declarations (not just definitions)</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1297"> <td><a href="https://cplusplus.github.io/CWG/issues/1297.html">1297</a></td> + <td>[<a href="https://wg21.link/dcl.decl">dcl.decl</a>]</td> <td>CD3</td> <td>Misplaced function <I>attribute-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1298"> <td><a href="https://cplusplus.github.io/CWG/issues/1298.html">1298</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>CD3</td> <td>Incorrect example in overload resolution</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1299"> <td><a href="https://cplusplus.github.io/CWG/issues/1299.html">1299</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD5</td> <td>“Temporary objects” vs “temporary expressions”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1300"> <td><a href="https://cplusplus.github.io/CWG/issues/1300.html">1300</a></td> + <td>[<a href="https://wg21.link/expr.type.conv">expr.type.conv</a>]</td> <td>dup</td> <td><TT>T()</TT> for array types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1301"> <td><a href="https://cplusplus.github.io/CWG/issues/1301.html">1301</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD3</td> <td>Value initialization of union</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1302"> <td><a href="https://cplusplus.github.io/CWG/issues/1302.html">1302</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>CD3</td> <td><TT>noexcept</TT> applied to expression of type <TT>void</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1303"> <td><a href="https://cplusplus.github.io/CWG/issues/1303.html">1303</a></td> + <td>[<a href="https://wg21.link/temp">temp</a>]</td> <td>NAD</td> <td>C language linkage for template with internal linkage</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1304"> <td><a href="https://cplusplus.github.io/CWG/issues/1304.html">1304</a></td> + <td>[<a href="https://wg21.link/dcl.init.string">dcl.init.string</a>]</td> <td>drafting</td> <td>Omitted array bound with string initialization</td> <td align="center">Not resolved</td> </tr> <tr id="1305"> <td><a href="https://cplusplus.github.io/CWG/issues/1305.html">1305</a></td> + <td>[<a href="https://wg21.link/expr.alignof">expr.alignof</a>]</td> <td>CD3</td> <td><TT>alignof</TT> applied to array of unknown size</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="1306"> <td><a href="https://cplusplus.github.io/CWG/issues/1306.html">1306</a></td> + <td>[<a href="https://wg21.link/class.this">class.this</a>]</td> <td>CD3</td> <td>Modifying an object within a <TT>const</TT> member function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1307"> <td><a href="https://cplusplus.github.io/CWG/issues/1307.html">1307</a></td> + <td>[<a href="https://wg21.link/over.ics.list">over.ics.list</a>]</td> <td>C++14</td> <td>Overload resolution based on size of array <I>initializer-list</I></td> <td class="full" align="center">Clang 14</td> </tr> <tr id="1308"> <td><a href="https://cplusplus.github.io/CWG/issues/1308.html">1308</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD3</td> <td>Completeness of class type within an <I>exception-specification</I></td> <td class="full-superseded" align="center">Superseded by <a href="#1330">1330</a></td> </tr> <tr id="1309"> <td><a href="https://cplusplus.github.io/CWG/issues/1309.html">1309</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>CD4</td> <td>Incorrect note regarding lookup of a member of the current instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1310"> <td><a href="https://cplusplus.github.io/CWG/issues/1310.html">1310</a></td> + <td>[<a href="https://wg21.link/class.qual">class.qual</a>]</td> <td>CD3</td> <td>What is an “acceptable lookup result?”</td> <td class="full" align="center">Clang 5</td> </tr> <tr id="1311"> <td><a href="https://cplusplus.github.io/CWG/issues/1311.html">1311</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>Volatile lvalues in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1312"> <td><a href="https://cplusplus.github.io/CWG/issues/1312.html">1312</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>Simulated <TT>reinterpret_cast</TT> in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1313"> <td><a href="https://cplusplus.github.io/CWG/issues/1313.html">1313</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>Undefined pointer arithmetic in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1314"> <td><a href="https://cplusplus.github.io/CWG/issues/1314.html">1314</a></td> + <td>[<a href="https://wg21.link/expr.add">expr.add</a>]</td> <td>NAD</td> <td>Pointer arithmetic within standard-layout objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1315"> <td><a href="https://cplusplus.github.io/CWG/issues/1315.html">1315</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial.general">temp.spec.partial.general</a>]</td> <td>CD4</td> <td>Restrictions on non-type template arguments in partial specializations</td> <td class="partial" align="center">Partial</td> </tr> <tr id="1316"> <td><a href="https://cplusplus.github.io/CWG/issues/1316.html">1316</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>NAD</td> <td><TT>constexpr</TT> function requirements and class scope</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1317"> <td><a href="https://cplusplus.github.io/CWG/issues/1317.html">1317</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>NAD</td> <td>Unnamed scoped enumerations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1318"> <td><a href="https://cplusplus.github.io/CWG/issues/1318.html">1318</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD3</td> <td>Syntactic ambiguities with <TT>final</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1319"> <td><a href="https://cplusplus.github.io/CWG/issues/1319.html">1319</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>NAD</td> <td>Error in pack expansion example</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1320"> <td><a href="https://cplusplus.github.io/CWG/issues/1320.html">1320</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD3</td> <td>Converting scoped enumerations to <TT>bool</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1321"> <td><a href="https://cplusplus.github.io/CWG/issues/1321.html">1321</a></td> + <td>[<a href="https://wg21.link/temp.over.link">temp.over.link</a>]</td> <td>CD3</td> <td>Equivalency of dependent calls</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1322"> <td><a href="https://cplusplus.github.io/CWG/issues/1322.html">1322</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>drafting</td> <td>Function parameter type decay in templates</td> <td align="center">Not resolved</td> </tr> <tr id="1323"> <td><a href="https://cplusplus.github.io/CWG/issues/1323.html">1323</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>NAD</td> <td>Nonexistent nonterminal in <I>alignment-specifier</I> grammar</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1324"> <td><a href="https://cplusplus.github.io/CWG/issues/1324.html">1324</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD3</td> <td>Value initialization and defaulted constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1325"> <td><a href="https://cplusplus.github.io/CWG/issues/1325.html">1325</a></td> + <td>[<a href="https://wg21.link/dcl.pre">dcl.pre</a>]</td> <td>NAD</td> <td>Omitted declarator in <TT>friend</TT> declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1326"> <td><a href="https://cplusplus.github.io/CWG/issues/1326.html">1326</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>dup</td> <td>Deducing an array bound from an <I>initializer-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1327"> <td><a href="https://cplusplus.github.io/CWG/issues/1327.html">1327</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD3</td> <td><I>virt-specifier</I> in a defaulted definition</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1328"> <td><a href="https://cplusplus.github.io/CWG/issues/1328.html">1328</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD3</td> <td>Conflict in reference binding vs overload resolution</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1329"> <td><a href="https://cplusplus.github.io/CWG/issues/1329.html">1329</a></td> + <td>[<a href="https://wg21.link/implimits">implimits</a>]</td> <td>CD3</td> <td>Recursive deduction substitutions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1330"> <td><a href="https://cplusplus.github.io/CWG/issues/1330.html">1330</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD3</td> <td>Delayed instantiation of <TT>noexcept</TT> specifiers</td> <td class="full" align="center">Clang 4 (C++11 onwards)</td> </tr> <tr id="1331"> <td><a href="https://cplusplus.github.io/CWG/issues/1331.html">1331</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD5</td> <td><TT>const</TT> mismatch with defaulted copy constructor</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1332"> <td><a href="https://cplusplus.github.io/CWG/issues/1332.html">1332</a></td> + <td>[<a href="https://wg21.link/lex.charset">lex.charset</a>]</td> <td>CD5</td> <td>Handling of invalid universal-character-names</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1333"> <td><a href="https://cplusplus.github.io/CWG/issues/1333.html">1333</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD3</td> <td>Omission of <TT>const</TT> in a defaulted copy constructor</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1334"> <td><a href="https://cplusplus.github.io/CWG/issues/1334.html">1334</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>NAD</td> <td>Layout compatibility and cv-qualification</td> <td class="full-superseded" align="center">Superseded by <a href="#1719">1719</a></td> </tr> <tr id="1335"> <td><a href="https://cplusplus.github.io/CWG/issues/1335.html">1335</a></td> + <td>[<a href="https://wg21.link/cpp.stringize">cpp.stringize</a>]</td> <td>CD6</td> <td>Stringizing, extended characters, and universal-character-names</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1336"> <td><a href="https://cplusplus.github.io/CWG/issues/1336.html">1336</a></td> + <td>[<a href="https://wg21.link/class.conv.ctor">class.conv.ctor</a>]</td> <td>CD3</td> <td>Definition of “converting constructor”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1337"> <td><a href="https://cplusplus.github.io/CWG/issues/1337.html">1337</a></td> + <td>[<a href="https://wg21.link/temp.deduct.partial">temp.deduct.partial</a>]</td> <td>dup</td> <td>Partial ordering and non-deduced parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1338"> <td><a href="https://cplusplus.github.io/CWG/issues/1338.html">1338</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.allocation">basic.stc.dynamic.allocation</a>]</td> <td>CD4</td> <td>Aliasing and allocation functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1339"> <td><a href="https://cplusplus.github.io/CWG/issues/1339.html">1339</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>NAD</td> <td>Parenthesized <I>braced-init-list</I> and arrays</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1340"> <td><a href="https://cplusplus.github.io/CWG/issues/1340.html">1340</a></td> + <td>[<a href="https://wg21.link/expr.mptr.oper">expr.mptr.oper</a>]</td> <td>CD3</td> <td>Complete type in member pointer expressions</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="1341"> <td><a href="https://cplusplus.github.io/CWG/issues/1341.html">1341</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>NAD</td> <td>Bit-field initializers</td> <td class="na" align="center">Superseded by <a href="https://wg21.link/P0683R1">P0683R1</a></td> </tr> <tr id="1342"> <td><a href="https://cplusplus.github.io/CWG/issues/1342.html">1342</a></td> + <td>[<a href="https://wg21.link/dcl.decl">dcl.decl</a>]</td> <td>CD6</td> <td>Order of initialization with multiple declarators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1343"> <td><a href="https://cplusplus.github.io/CWG/issues/1343.html">1343</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>C++17</td> <td>Sequencing of non-class initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1344"> <td><a href="https://cplusplus.github.io/CWG/issues/1344.html">1344</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++14</td> <td>Adding new special member functions to a class via default arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1345"> <td><a href="https://cplusplus.github.io/CWG/issues/1345.html">1345</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>CD3</td> <td>Initialization of anonymous union class members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1346"> <td><a href="https://cplusplus.github.io/CWG/issues/1346.html">1346</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD3</td> <td><I>expression-list</I> initializers and the <TT>auto</TT> specifier</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="1347"> <td><a href="https://cplusplus.github.io/CWG/issues/1347.html">1347</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD3</td> <td>Consistency of <TT>auto</TT> in multiple-declarator declarations</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr class="open" id="1348"> <td><a href="https://cplusplus.github.io/CWG/issues/1348.html">1348</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>drafting</td> <td>Use of <TT>auto</TT> in a <I>trailing-return-type</I></td> <td align="center">Not resolved</td> </tr> <tr id="1349"> <td><a href="https://cplusplus.github.io/CWG/issues/1349.html">1349</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>dup</td> <td>Consistency of alias template redeclarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1350"> <td><a href="https://cplusplus.github.io/CWG/issues/1350.html">1350</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>CD3</td> <td>Incorrect exception specification for inherited constructors</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="1351"> <td><a href="https://cplusplus.github.io/CWG/issues/1351.html">1351</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD4</td> <td>Problems with implicitly-declared <I>exception-specification</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1352"> <td><a href="https://cplusplus.github.io/CWG/issues/1352.html">1352</a></td> + <td>[<a href="https://wg21.link/basic.scope.class">basic.scope.class</a>]</td> <td>CD3</td> <td>Inconsistent class scope and completeness rules</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="1353"> <td><a href="https://cplusplus.github.io/CWG/issues/1353.html">1353</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>CD7</td> <td>Array and variant members and deleted special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1354"> <td><a href="https://cplusplus.github.io/CWG/issues/1354.html">1354</a></td> + <td>[<a href="https://wg21.link/expr.unary.noexcept">expr.unary.noexcept</a>]</td> <td>CD3</td> <td>Destructor exceptions for temporaries in noexcept expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1355"> <td><a href="https://cplusplus.github.io/CWG/issues/1355.html">1355</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD3</td> <td>Aggregates and “user-provided” constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1356"> <td><a href="https://cplusplus.github.io/CWG/issues/1356.html">1356</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD4</td> <td>Exception specifications of copy assignment operators with virtual bases</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1357"> <td><a href="https://cplusplus.github.io/CWG/issues/1357.html">1357</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD3</td> <td><I>brace-or-equal-initializer</I>s for function and typedef members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1358"> <td><a href="https://cplusplus.github.io/CWG/issues/1358.html">1358</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD3</td> <td>Unintentionally ill-formed <TT>constexpr</TT> function template instances</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="1359"> <td><a href="https://cplusplus.github.io/CWG/issues/1359.html">1359</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD3</td> <td><TT>constexpr</TT> union constructors</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="1360"> <td><a href="https://cplusplus.github.io/CWG/issues/1360.html">1360</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>CD6</td> <td><TT>constexpr</TT> defaulted default constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1361"> <td><a href="https://cplusplus.github.io/CWG/issues/1361.html">1361</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>CD3</td> <td>Requirement on <I>brace-or-equal-initializer</I>s of literal types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1362"> <td><a href="https://cplusplus.github.io/CWG/issues/1362.html">1362</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD3</td> <td>Complete type required for implicit conversion to <TT>T&</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1363"> <td><a href="https://cplusplus.github.io/CWG/issues/1363.html">1363</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD3</td> <td>Triviality vs multiple default constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1364"> <td><a href="https://cplusplus.github.io/CWG/issues/1364.html">1364</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td><TT>constexpr</TT> function parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1365"> <td><a href="https://cplusplus.github.io/CWG/issues/1365.html">1365</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>Calling undefined <TT>constexpr</TT> functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1366"> <td><a href="https://cplusplus.github.io/CWG/issues/1366.html">1366</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD3</td> <td>Deleted <TT>constexpr</TT> constructors and virtual base classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1367"> <td><a href="https://cplusplus.github.io/CWG/issues/1367.html">1367</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>Use of <TT>this</TT> in a constant expression</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1368"> <td><a href="https://cplusplus.github.io/CWG/issues/1368.html">1368</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD3</td> <td>Value initialization and defaulted constructors (part 2)</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1369"> <td><a href="https://cplusplus.github.io/CWG/issues/1369.html">1369</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD3</td> <td>Function invocation substitution of <TT>this</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1370"> <td><a href="https://cplusplus.github.io/CWG/issues/1370.html">1370</a></td> + <td>[<a href="https://wg21.link/cpp.replace">cpp.replace</a>]</td> <td>CD3</td> <td><I>identifier-list</I> cannot contain ellipsis</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1371"> <td><a href="https://cplusplus.github.io/CWG/issues/1371.html">1371</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>NAD</td> <td>Deduction from <TT>T&&</TT> in return types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1372"> <td><a href="https://cplusplus.github.io/CWG/issues/1372.html">1372</a></td> + <td>[<a href="https://wg21.link/temp.deduct.conv">temp.deduct.conv</a>]</td> <td>CD3</td> <td>Cross-references incorrect in conversion function template argument deduction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1373"> <td><a href="https://cplusplus.github.io/CWG/issues/1373.html">1373</a></td> + <td>[<a href="https://wg21.link/over.match.ref">over.match.ref</a>]</td> <td>dup</td> <td>Overload resolution changes matching reference-binding changes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1374"> <td><a href="https://cplusplus.github.io/CWG/issues/1374.html">1374</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>CD3</td> <td>Qualification conversion vs difference in reference binding</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1375"> <td><a href="https://cplusplus.github.io/CWG/issues/1375.html">1375</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>CD3</td> <td>Reference to anonymous union?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1376"> <td><a href="https://cplusplus.github.io/CWG/issues/1376.html">1376</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>C++14</td> <td><TT>static_cast</TT> of temporary to rvalue reference</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1377"> <td><a href="https://cplusplus.github.io/CWG/issues/1377.html">1377</a></td> + <td>[<a href="https://wg21.link/diff.cpp03">diff.cpp03</a>]</td> <td>dup</td> <td>Access declarations not mentioned in Annex C</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1378"> <td><a href="https://cplusplus.github.io/CWG/issues/1378.html">1378</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>CD5</td> <td>When is an instantiation required?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1379"> <td><a href="https://cplusplus.github.io/CWG/issues/1379.html">1379</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>NAD</td> <td>Is <TT>std::initializer_list</TT> an aggregate?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1380"> <td><a href="https://cplusplus.github.io/CWG/issues/1380.html">1380</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD3</td> <td>Type definitions in <I>template-parameter</I> <I>parameter-declaration</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1381"> <td><a href="https://cplusplus.github.io/CWG/issues/1381.html">1381</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD3</td> <td>Implicitly-declared special member functions and default <TT>nothrow</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1382"> <td><a href="https://cplusplus.github.io/CWG/issues/1382.html">1382</a></td> + <td>[<a href="https://wg21.link/dcl.decl">dcl.decl</a>]</td> <td>CD3</td> <td>Dead code for constructor names</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1383"> <td><a href="https://cplusplus.github.io/CWG/issues/1383.html">1383</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>CD3</td> <td>Clarifying discarded-value expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1384"> <td><a href="https://cplusplus.github.io/CWG/issues/1384.html">1384</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td><TT>reinterpret_cast</TT> in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1385"> <td><a href="https://cplusplus.github.io/CWG/issues/1385.html">1385</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>CD3</td> <td>Syntactic forms of conversion functions for surrogate call functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1386"> <td><a href="https://cplusplus.github.io/CWG/issues/1386.html">1386</a></td> + <td>[<a href="https://wg21.link/temp.arg.explicit">temp.arg.explicit</a>]</td> <td>NAD</td> <td>Explicitly-specified partial argument list with multiple parameter packs</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1387"> <td><a href="https://cplusplus.github.io/CWG/issues/1387.html">1387</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>CD3</td> <td>Missing non-deduced context for <TT>decltype</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1388"> <td><a href="https://cplusplus.github.io/CWG/issues/1388.html">1388</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>CD3</td> <td>Missing non-deduced context following a function parameter pack</td> <td class="full" align="center">Clang 4</td> </tr> <tr id="1389"> <td><a href="https://cplusplus.github.io/CWG/issues/1389.html">1389</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>NAD</td> <td>Recursive reference in <I>trailing-return-type</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1390"> <td><a href="https://cplusplus.github.io/CWG/issues/1390.html">1390</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>drafting</td> <td>Dependency of alias template specializations</td> <td align="center">Not resolved</td> </tr> <tr id="1391"> <td><a href="https://cplusplus.github.io/CWG/issues/1391.html">1391</a></td> + <td>[<a href="https://wg21.link/temp.arg.explicit">temp.arg.explicit</a>]</td> <td>CD4</td> <td>Conversions to parameter types with non-deduced template arguments</td> <td class="partial" align="center">Partial</td> </tr> <tr id="1392"> <td><a href="https://cplusplus.github.io/CWG/issues/1392.html">1392</a></td> + <td>[<a href="https://wg21.link/over.match.ref">over.match.ref</a>]</td> <td>CD3</td> <td>Explicit conversion functions for references and non-references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1393"> <td><a href="https://cplusplus.github.io/CWG/issues/1393.html">1393</a></td> + <td>[<a href="https://wg21.link/temp.variadic">temp.variadic</a>]</td> <td>C++17</td> <td>Pack expansions in <I>using-declaration</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1394"> <td><a href="https://cplusplus.github.io/CWG/issues/1394.html">1394</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD3</td> <td>Incomplete types as parameters of deleted functions</td> <td class="full" align="center">Clang 15</td> </tr> <tr id="1395"> <td><a href="https://cplusplus.github.io/CWG/issues/1395.html">1395</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>C++17</td> <td>Partial ordering of variadic templates reconsidered</td> <td class="full" align="center">Clang 16</td> </tr> <tr id="1396"> <td><a href="https://cplusplus.github.io/CWG/issues/1396.html">1396</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>C++23</td> <td>Deferred instantiation and checking of non-static data member initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1397"> <td><a href="https://cplusplus.github.io/CWG/issues/1397.html">1397</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD4</td> <td>Class completeness in non-static data member initializers</td> <td class="full" align="center">Clang 3.2</td> </tr> <tr id="1398"> <td><a href="https://cplusplus.github.io/CWG/issues/1398.html">1398</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>CD3</td> <td>Non-type template parameters of type <TT>std::nullptr_t</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1399"> <td><a href="https://cplusplus.github.io/CWG/issues/1399.html">1399</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>CD3</td> <td>Deduction with multiple function parameter packs</td> <td class="full" align="center">Duplicate of <a href="#1388">1388</a></td> </tr> <tr id="1400"> <td><a href="https://cplusplus.github.io/CWG/issues/1400.html">1400</a></td> + <td>[<a href="https://wg21.link/expr.eq">expr.eq</a>]</td> <td>NAD</td> <td>Function pointer equality</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1401"> <td><a href="https://cplusplus.github.io/CWG/issues/1401.html">1401</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD3</td> <td>Similar types and reference compatibility</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1402"> <td><a href="https://cplusplus.github.io/CWG/issues/1402.html">1402</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD3</td> <td>Move functions too often deleted</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1403"> <td><a href="https://cplusplus.github.io/CWG/issues/1403.html">1403</a></td> + <td>[<a href="https://wg21.link/lex.comment">lex.comment</a>]</td> <td>CD6</td> <td>Universal-character-names in comments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1404"> <td><a href="https://cplusplus.github.io/CWG/issues/1404.html">1404</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>open</td> <td>Object reallocation in unions</td> <td align="center">Not resolved</td> </tr> <tr id="1405"> <td><a href="https://cplusplus.github.io/CWG/issues/1405.html">1405</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>CD3</td> <td><TT>constexpr</TT> and mutable members of literal types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1406"> <td><a href="https://cplusplus.github.io/CWG/issues/1406.html">1406</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>CD3</td> <td><I>ref-qualifier</I>s and added parameters of non-static member function templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1407"> <td><a href="https://cplusplus.github.io/CWG/issues/1407.html">1407</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td>Integral to <TT>bool</TT> conversion in converted constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1408"> <td><a href="https://cplusplus.github.io/CWG/issues/1408.html">1408</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>CD3</td> <td>What is “the same aggregate initialization?”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1409"> <td><a href="https://cplusplus.github.io/CWG/issues/1409.html">1409</a></td> + <td>[<a href="https://wg21.link/over.ics.list">over.ics.list</a>]</td> <td>CD3</td> <td>What is the second standard conversion sequence of a list-initialization sequence?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1410"> <td><a href="https://cplusplus.github.io/CWG/issues/1410.html">1410</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>CD3</td> <td>Reference overload tiebreakers should apply to rvalue references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1411"> <td><a href="https://cplusplus.github.io/CWG/issues/1411.html">1411</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD3</td> <td>More on global scope <TT>::</TT> in <I>nested-name-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1412"> <td><a href="https://cplusplus.github.io/CWG/issues/1412.html">1412</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD3</td> <td>Problems in specifying pointer conversions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1413"> <td><a href="https://cplusplus.github.io/CWG/issues/1413.html">1413</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>CD3</td> <td>Missing cases of value-dependency</td> <td class="full" align="center">Clang 12</td> </tr> <tr class="open" id="1414"> <td><a href="https://cplusplus.github.io/CWG/issues/1414.html">1414</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>drafting</td> <td>Binding an rvalue reference to a reference-unrelated lvalue</td> <td align="center">Not resolved</td> </tr> <tr id="1415"> <td><a href="https://cplusplus.github.io/CWG/issues/1415.html">1415</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD3</td> <td>Missing prohibition of block-scope definition of <TT>extern</TT> object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1416"> <td><a href="https://cplusplus.github.io/CWG/issues/1416.html">1416</a></td> + <td>[<a href="https://wg21.link/expr.typeid">expr.typeid</a>]</td> <td>CD3</td> <td>Function cv-qualifiers and <TT>typeid</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1417"> <td><a href="https://cplusplus.github.io/CWG/issues/1417.html">1417</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>C++14</td> <td>Pointers/references to functions with cv-qualifiers or <I>ref-qualifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1418"> <td><a href="https://cplusplus.github.io/CWG/issues/1418.html">1418</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD3</td> <td>Type of <TT>initializer_list</TT> backing array</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1419"> <td><a href="https://cplusplus.github.io/CWG/issues/1419.html">1419</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>NAD</td> <td>Evaluation order in aggregate initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1420"> <td><a href="https://cplusplus.github.io/CWG/issues/1420.html">1420</a></td> + <td>[<a href="https://wg21.link/class.abstract">class.abstract</a>]</td> <td>NAD</td> <td>Abstract final classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1421"> <td><a href="https://cplusplus.github.io/CWG/issues/1421.html">1421</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>NAD</td> <td>Full expressions and aggregate initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1422"> <td><a href="https://cplusplus.github.io/CWG/issues/1422.html">1422</a></td> + <td>[<a href="https://wg21.link/lex.ccon">lex.ccon</a>]</td> <td>dup</td> <td>Type of character literals containing universal-character-names</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1423"> <td><a href="https://cplusplus.github.io/CWG/issues/1423.html">1423</a></td> + <td>[<a href="https://wg21.link/conv.fctptr">conv.fctptr</a>]</td> <td>CD3</td> <td>Convertibility of <TT>nullptr</TT> to <TT>bool</TT></td> <td class="full" align="center">Clang 11</td> </tr> <tr id="1424"> <td><a href="https://cplusplus.github.io/CWG/issues/1424.html">1424</a></td> + <td>[<a href="https://wg21.link/except.ctor">except.ctor</a>]</td> <td>C++14</td> <td>When must sub-object destructors be accessible?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1425"> <td><a href="https://cplusplus.github.io/CWG/issues/1425.html">1425</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD3</td> <td>Base-class subobjects of standard-layout structs</td> <td class="na" align="center">N/A (ABI constraint)</td> </tr> <tr id="1426"> <td><a href="https://cplusplus.github.io/CWG/issues/1426.html">1426</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD5</td> <td>Allowing additional parameter types in defaulted functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1427"> <td><a href="https://cplusplus.github.io/CWG/issues/1427.html">1427</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>NAD</td> <td>Default constructor and deleted or inaccessible destructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1428"> <td><a href="https://cplusplus.github.io/CWG/issues/1428.html">1428</a></td> + <td>[<a href="https://wg21.link/basic.type.qualifier">basic.type.qualifier</a>]</td> <td>CD3</td> <td>Dynamic const objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1429"> <td><a href="https://cplusplus.github.io/CWG/issues/1429.html">1429</a></td> + <td>[<a href="https://wg21.link/basic.scope.temp">basic.scope.temp</a>]</td> <td>NAD</td> <td>Scope of a member template's template parameter</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1430"> <td><a href="https://cplusplus.github.io/CWG/issues/1430.html">1430</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>open</td> <td>Pack expansion into fixed alias template parameter list</td> <td align="center">Not resolved</td> </tr> <tr id="1431"> <td><a href="https://cplusplus.github.io/CWG/issues/1431.html">1431</a></td> + <td>[<a href="https://wg21.link/except">except</a>]</td> <td>CD3</td> <td>Exceptions from other than <I>throw-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1432"> <td><a href="https://cplusplus.github.io/CWG/issues/1432.html">1432</a></td> + <td>[<a href="https://wg21.link/temp.variadic">temp.variadic</a>]</td> <td>open</td> <td>Newly-ambiguous variadic template expansions</td> <td align="center"> @@ -8419,912 +9809,1064 @@ and <I>POD class</I></td> </tr> <tr id="1433"> <td><a href="https://cplusplus.github.io/CWG/issues/1433.html">1433</a></td> + <td>[<a href="https://wg21.link/basic.scope.pdecl">basic.scope.pdecl</a>]</td> <td>NAD</td> <td><I>trailing-return-type</I> and point of declaration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1434"> <td><a href="https://cplusplus.github.io/CWG/issues/1434.html">1434</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>NAD</td> <td>Parenthesized <I>braced-init-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1435"> <td><a href="https://cplusplus.github.io/CWG/issues/1435.html">1435</a></td> + <td>[<a href="https://wg21.link/dcl.meaning">dcl.meaning</a>]</td> <td>CD3</td> <td><I>template-id</I> as the declarator for a class template constructor</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1436"> <td><a href="https://cplusplus.github.io/CWG/issues/1436.html">1436</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>open</td> <td>Interaction of constant expression changes with preprocessor expressions</td> <td align="center">Not resolved</td> </tr> <tr id="1437"> <td><a href="https://cplusplus.github.io/CWG/issues/1437.html">1437</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>CD3</td> <td><TT>alignas</TT> in <I>alias-declaration</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1438"> <td><a href="https://cplusplus.github.io/CWG/issues/1438.html">1438</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.safety">basic.stc.dynamic.safety</a>]</td> <td>CD3</td> <td>Non-dereference use of invalid pointers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1439"> <td><a href="https://cplusplus.github.io/CWG/issues/1439.html">1439</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>CD3</td> <td>Lookup and friend template declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1440"> <td><a href="https://cplusplus.github.io/CWG/issues/1440.html">1440</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>CD3</td> <td>Acceptable <I>decltype-specifier</I>s used as <I>nested-name-specifier</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1441"> <td><a href="https://cplusplus.github.io/CWG/issues/1441.html">1441</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>C++14</td> <td>Unclear wording for signal handler restrictions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1442"> <td><a href="https://cplusplus.github.io/CWG/issues/1442.html">1442</a></td> + <td>[<a href="https://wg21.link/stmt.ranged">stmt.ranged</a>]</td> <td>CD3</td> <td>Argument-dependent lookup in the range-based <TT>for</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1443"> <td><a href="https://cplusplus.github.io/CWG/issues/1443.html">1443</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>NAD</td> <td>Default arguments and non-static data members</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="1444"> <td><a href="https://cplusplus.github.io/CWG/issues/1444.html">1444</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>drafting</td> <td>Type adjustments of non-type template parameters</td> <td align="center">Not resolved</td> </tr> <tr id="1445"> <td><a href="https://cplusplus.github.io/CWG/issues/1445.html">1445</a></td> + <td>[<a href="https://wg21.link/stmt.ranged">stmt.ranged</a>]</td> <td>dup</td> <td>Argument-dependent lookup of <TT>begin</TT> and <TT>end</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1446"> <td><a href="https://cplusplus.github.io/CWG/issues/1446.html">1446</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>CD4</td> <td>Member function with no <I>ref-qualifier</I> and non-member function with rvalue reference</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1447"> <td><a href="https://cplusplus.github.io/CWG/issues/1447.html">1447</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD3</td> <td><TT>static_cast</TT> of bit-field lvalue to rvalue reference</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1448"> <td><a href="https://cplusplus.github.io/CWG/issues/1448.html">1448</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>NAD</td> <td>Integral values of type <TT>bool</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1449"> <td><a href="https://cplusplus.github.io/CWG/issues/1449.html">1449</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD3</td> <td>Narrowing conversion of negative value to unsigned type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1450"> <td><a href="https://cplusplus.github.io/CWG/issues/1450.html">1450</a></td> + <td>[<a href="https://wg21.link/expr.mul">expr.mul</a>]</td> <td>CD3</td> <td><TT>INT_MIN % -1</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1451"> <td><a href="https://cplusplus.github.io/CWG/issues/1451.html">1451</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>CD4</td> <td>Objects with no linkage in non-type template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1452"> <td><a href="https://cplusplus.github.io/CWG/issues/1452.html">1452</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td>Value-initialized objects may be constants</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1453"> <td><a href="https://cplusplus.github.io/CWG/issues/1453.html">1453</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>CD3</td> <td>Volatile members in literal classes?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1454"> <td><a href="https://cplusplus.github.io/CWG/issues/1454.html">1454</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>Passing constants through <TT>constexpr</TT> functions via references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1455"> <td><a href="https://cplusplus.github.io/CWG/issues/1455.html">1455</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>Lvalue converted constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1456"> <td><a href="https://cplusplus.github.io/CWG/issues/1456.html">1456</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>Address constant expression designating the one-past-the-end address</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1457"> <td><a href="https://cplusplus.github.io/CWG/issues/1457.html">1457</a></td> + <td>[<a href="https://wg21.link/expr.shift">expr.shift</a>]</td> <td>CD3</td> <td>Undefined behavior in left-shift</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1458"> <td><a href="https://cplusplus.github.io/CWG/issues/1458.html">1458</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>CD3</td> <td>Address of incomplete type vs <TT>operator&()</TT></td> <td class="full" align="center">Clang 3.1</td> </tr> <tr class="open" id="1459"> <td><a href="https://cplusplus.github.io/CWG/issues/1459.html">1459</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>open</td> <td>Reference-binding tiebreakers in overload resolution</td> <td align="center">Not resolved</td> </tr> <tr id="1460"> <td><a href="https://cplusplus.github.io/CWG/issues/1460.html">1460</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>C++14</td> <td>What is an empty union?</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="1461"> <td><a href="https://cplusplus.github.io/CWG/issues/1461.html">1461</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>NAD</td> <td>Narrowing conversions to bit-fields</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1462"> <td><a href="https://cplusplus.github.io/CWG/issues/1462.html">1462</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD3</td> <td>Deduction failure vs “ill-formed, no diagnostic required”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1463"> <td><a href="https://cplusplus.github.io/CWG/issues/1463.html">1463</a></td> + <td>[<a href="https://wg21.link/temp.pre">temp.pre</a>]</td> <td>drafting</td> <td><TT>extern "C"</TT> alias templates</td> <td align="center">Not resolved</td> </tr> <tr id="1464"> <td><a href="https://cplusplus.github.io/CWG/issues/1464.html">1464</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD3</td> <td>Negative array bound in a <I>new-expression</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1465"> <td><a href="https://cplusplus.github.io/CWG/issues/1465.html">1465</a></td> + <td>[<a href="https://wg21.link/expr.unary.noexcept">expr.unary.noexcept</a>]</td> <td>CD4</td> <td><TT>noexcept</TT> and <TT>std::bad_array_new_length</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1466"> <td><a href="https://cplusplus.github.io/CWG/issues/1466.html">1466</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>C++14</td> <td>Visible sequences of side effects are redundant</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1467"> <td><a href="https://cplusplus.github.io/CWG/issues/1467.html">1467</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD4</td> <td>List-initialization of aggregate from same-type object</td> <td class="full" align="center">Clang 3.7 (C++11 onwards)</td> </tr> <tr id="1468"> <td><a href="https://cplusplus.github.io/CWG/issues/1468.html">1468</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD5</td> <td><TT>typeid</TT>, overload resolution, and implicit lambda capture</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1469"> <td><a href="https://cplusplus.github.io/CWG/issues/1469.html">1469</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD5</td> <td>Omitted bound in array <I>new-expression</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1470"> <td><a href="https://cplusplus.github.io/CWG/issues/1470.html">1470</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>NAD</td> <td>Thread migration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1471"> <td><a href="https://cplusplus.github.io/CWG/issues/1471.html">1471</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>CD3</td> <td>Nested type of non-dependent base</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1472"> <td><a href="https://cplusplus.github.io/CWG/issues/1472.html">1472</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD3</td> <td>odr-use of reference variables</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1473"> <td><a href="https://cplusplus.github.io/CWG/issues/1473.html">1473</a></td> + <td>[<a href="https://wg21.link/over.literal">over.literal</a>]</td> <td>CD3</td> <td>Syntax of <I>literal-operator-id</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1474"> <td><a href="https://cplusplus.github.io/CWG/issues/1474.html">1474</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>NAD</td> <td>User-defined literals and <TT><inttypes.h></TT> format macros</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1475"> <td><a href="https://cplusplus.github.io/CWG/issues/1475.html">1475</a></td> + <td>[<a href="https://wg21.link/dcl.attr.depend">dcl.attr.depend</a>]</td> <td>CD3</td> <td>Errors in <TT>[[carries_dependency]]</TT> example</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1476"> <td><a href="https://cplusplus.github.io/CWG/issues/1476.html">1476</a></td> + <td>[<a href="https://wg21.link/intro.defs">intro.defs</a>]</td> <td>CD3</td> <td>Definition of user-defined type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1477"> <td><a href="https://cplusplus.github.io/CWG/issues/1477.html">1477</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>CD3</td> <td>Definition of a <TT>friend</TT> outside its namespace</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="1478"> <td><a href="https://cplusplus.github.io/CWG/issues/1478.html">1478</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>CD6</td> <td><TT>template</TT> keyword for dependent template template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1479"> <td><a href="https://cplusplus.github.io/CWG/issues/1479.html">1479</a></td> + <td>[<a href="https://wg21.link/over.literal">over.literal</a>]</td> <td>CD3</td> <td>Literal operators and default arguments</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="1480"> <td><a href="https://cplusplus.github.io/CWG/issues/1480.html">1480</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>Constant initialization via non-constant temporary</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1481"> <td><a href="https://cplusplus.github.io/CWG/issues/1481.html">1481</a></td> + <td>[<a href="https://wg21.link/over.inc">over.inc</a>]</td> <td>CD3</td> <td>Increment/decrement operators with reference parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1482"> <td><a href="https://cplusplus.github.io/CWG/issues/1482.html">1482</a></td> + <td>[<a href="https://wg21.link/basic.scope.pdecl">basic.scope.pdecl</a>]</td> <td>CD3</td> <td>Point of declaration of enumeration</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="1483"> <td><a href="https://cplusplus.github.io/CWG/issues/1483.html">1483</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>NAD</td> <td>Non-dependent <I>static_assert-declaration</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1484"> <td><a href="https://cplusplus.github.io/CWG/issues/1484.html">1484</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>CD4</td> <td>Unused local classes of function templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1485"> <td><a href="https://cplusplus.github.io/CWG/issues/1485.html">1485</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>drafting</td> <td>Out-of-class definition of member unscoped opaque enumeration</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1486"> <td><a href="https://cplusplus.github.io/CWG/issues/1486.html">1486</a></td> + <td>[<a href="https://wg21.link/temp.deduct.funcaddr">temp.deduct.funcaddr</a>]</td> <td>drafting</td> <td>Base-derived conversion in member pointer deduction</td> <td align="center">Not resolved</td> </tr> <tr id="1487"> <td><a href="https://cplusplus.github.io/CWG/issues/1487.html">1487</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>CD3</td> <td>When are inheriting constructors declared?</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr class="open" id="1488"> <td><a href="https://cplusplus.github.io/CWG/issues/1488.html">1488</a></td> + <td>[<a href="https://wg21.link/dcl.name">dcl.name</a>]</td> <td>drafting</td> <td><I>abstract-pack-declarator</I>s in <I>type-id</I>s</td> <td align="center">Not resolved</td> </tr> <tr id="1489"> <td><a href="https://cplusplus.github.io/CWG/issues/1489.html">1489</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>CD3</td> <td>Is value-initialization of an array constant initialization?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1490"> <td><a href="https://cplusplus.github.io/CWG/issues/1490.html">1490</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD4</td> <td>List-initialization from a string literal</td> <td class="full" align="center">Clang 3.7 (C++11 onwards)</td> </tr> <tr id="1491"> <td><a href="https://cplusplus.github.io/CWG/issues/1491.html">1491</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD3</td> <td>Move construction and rvalue reference members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1492"> <td><a href="https://cplusplus.github.io/CWG/issues/1492.html">1492</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD4</td> <td>Exception specifications on template destructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1493"> <td><a href="https://cplusplus.github.io/CWG/issues/1493.html">1493</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++14</td> <td>Criteria for move-construction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1494"> <td><a href="https://cplusplus.github.io/CWG/issues/1494.html">1494</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD3</td> <td>Temporary initialization for reference binding in list-initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1495"> <td><a href="https://cplusplus.github.io/CWG/issues/1495.html">1495</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial">temp.spec.partial</a>]</td> <td>CD3</td> <td>Partial specialization of variadic class template</td> <td class="full" align="center">Clang 4</td> </tr> <tr id="1496"> <td><a href="https://cplusplus.github.io/CWG/issues/1496.html">1496</a></td> + <td>[<a href="https://wg21.link/class.name">class.name</a>]</td> <td>CD4</td> <td>Triviality with deleted and missing default constructors</td> <td class="none" align="center">No</td> </tr> <tr id="1497"> <td><a href="https://cplusplus.github.io/CWG/issues/1497.html">1497</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>NAD</td> <td>Aggregate initialization with parenthesized string literal</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1498"> <td><a href="https://cplusplus.github.io/CWG/issues/1498.html">1498</a></td> + <td>[<a href="https://wg21.link/stmt.ranged">stmt.ranged</a>]</td> <td>dup</td> <td>Lifetime of temporaries in range-based <TT>for</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1499"> <td><a href="https://cplusplus.github.io/CWG/issues/1499.html">1499</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>CD7</td> <td>Missing case for deleted move assignment operator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1500"> <td><a href="https://cplusplus.github.io/CWG/issues/1500.html">1500</a></td> + <td>[<a href="https://wg21.link/temp.dep.candidate">temp.dep.candidate</a>]</td> <td>CD6</td> <td>Name lookup of dependent conversion function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1501"> <td><a href="https://cplusplus.github.io/CWG/issues/1501.html">1501</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>NAD</td> <td>Nested braces in list-initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1502"> <td><a href="https://cplusplus.github.io/CWG/issues/1502.html">1502</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD3</td> <td>Value initialization of unions with member initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1503"> <td><a href="https://cplusplus.github.io/CWG/issues/1503.html">1503</a></td> + <td>[<a href="https://wg21.link/except.throw">except.throw</a>]</td> <td>CD3</td> <td>Exceptions during copy to exception object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1504"> <td><a href="https://cplusplus.github.io/CWG/issues/1504.html">1504</a></td> + <td>[<a href="https://wg21.link/expr.add">expr.add</a>]</td> <td>CD3</td> <td>Pointer arithmetic after derived-base conversion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1505"> <td><a href="https://cplusplus.github.io/CWG/issues/1505.html">1505</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>dup</td> <td>Direct binding of reference to temporary in list-initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1506"> <td><a href="https://cplusplus.github.io/CWG/issues/1506.html">1506</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD3</td> <td>Value category of <TT>initializer_list</TT> object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1507"> <td><a href="https://cplusplus.github.io/CWG/issues/1507.html">1507</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD3</td> <td>Value initialization with trivial inaccessible default constructor</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1508"> <td><a href="https://cplusplus.github.io/CWG/issues/1508.html">1508</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>C++14</td> <td>Template initializer-list constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1509"> <td><a href="https://cplusplus.github.io/CWG/issues/1509.html">1509</a></td> + <td>[<a href="https://wg21.link/intro.defs">intro.defs</a>]</td> <td>C++14</td> <td>Definition of “non-template function”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1510"> <td><a href="https://cplusplus.github.io/CWG/issues/1510.html">1510</a></td> + <td>[<a href="https://wg21.link/dcl.ref">dcl.ref</a>]</td> <td>CD3</td> <td>cv-qualified references via <TT>decltype</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1511"> <td><a href="https://cplusplus.github.io/CWG/issues/1511.html">1511</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD3</td> <td><TT>const volatile</TT> variables and the one-definition rule</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1512"> <td><a href="https://cplusplus.github.io/CWG/issues/1512.html">1512</a></td> + <td>[<a href="https://wg21.link/expr.rel">expr.rel</a>]</td> <td>CD3</td> <td>Pointer comparison vs qualification conversions</td> <td class="full" align="center">Clang 4</td> </tr> <tr class="open" id="1513"> <td><a href="https://cplusplus.github.io/CWG/issues/1513.html">1513</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>drafting</td> <td><TT>initializer_list</TT> deduction failure</td> <td align="center">Not resolved</td> </tr> <tr id="1514"> <td><a href="https://cplusplus.github.io/CWG/issues/1514.html">1514</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>C++14</td> <td>Ambiguity between enumeration definition and zero-length bit-field</td> <td class="full" align="center">Clang 11</td> </tr> <tr id="1515"> <td><a href="https://cplusplus.github.io/CWG/issues/1515.html">1515</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>CD3</td> <td>Modulo 2<SUP><I>n</I></SUP> arithmetic for implicitly-unsigned types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1516"> <td><a href="https://cplusplus.github.io/CWG/issues/1516.html">1516</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD3</td> <td>Definition of “virtual function call”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1517"> <td><a href="https://cplusplus.github.io/CWG/issues/1517.html">1517</a></td> + <td>[<a href="https://wg21.link/class.cdtor">class.cdtor</a>]</td> <td>open</td> <td>Unclear/missing description of behavior during construction/destruction</td> <td align="center">Not resolved</td> </tr> <tr id="1518"> <td><a href="https://cplusplus.github.io/CWG/issues/1518.html">1518</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD4</td> <td>Explicit default constructors and copy-list-initialization</td> <td class="full" align="center">Clang 4</td> </tr> <tr id="1519"> <td><a href="https://cplusplus.github.io/CWG/issues/1519.html">1519</a></td> + <td>[<a href="https://wg21.link/temp.variadic">temp.variadic</a>]</td> <td>NAD</td> <td>Conflicting default and variadic constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1520"> <td><a href="https://cplusplus.github.io/CWG/issues/1520.html">1520</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>NAD</td> <td>Alias template specialization vs pack expansion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1521"> <td><a href="https://cplusplus.github.io/CWG/issues/1521.html">1521</a></td> + <td>[<a href="https://wg21.link/expr.type.conv">expr.type.conv</a>]</td> <td>dup</td> <td><TT>T{</TT><I>expr</I><TT>}</TT> with reference types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1522"> <td><a href="https://cplusplus.github.io/CWG/issues/1522.html">1522</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD3</td> <td>Access checking for <TT>initializer_list</TT> array initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1523"> <td><a href="https://cplusplus.github.io/CWG/issues/1523.html">1523</a></td> + <td>[<a href="https://wg21.link/stmt.ranged">stmt.ranged</a>]</td> <td>CD5</td> <td>Point of declaration in range-based <TT>for</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1524"> <td><a href="https://cplusplus.github.io/CWG/issues/1524.html">1524</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>drafting</td> <td>Incompletely-defined class template base</td> <td align="center">Not resolved</td> </tr> <tr id="1525"> <td><a href="https://cplusplus.github.io/CWG/issues/1525.html">1525</a></td> + <td>[<a href="https://wg21.link/expr.type.conv">expr.type.conv</a>]</td> <td>NAD</td> <td>Array bound inference in temporary array</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1526"> <td><a href="https://cplusplus.github.io/CWG/issues/1526.html">1526</a></td> + <td>[<a href="https://wg21.link/temp.dep">temp.dep</a>]</td> <td>dup</td> <td>Dependent-class lookup in the current instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1527"> <td><a href="https://cplusplus.github.io/CWG/issues/1527.html">1527</a></td> + <td>[<a href="https://wg21.link/expr.assign">expr.assign</a>]</td> <td>CD3</td> <td>Assignment from <I>braced-init-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1528"> <td><a href="https://cplusplus.github.io/CWG/issues/1528.html">1528</a></td> + <td>[<a href="https://wg21.link/dcl.decl">dcl.decl</a>]</td> <td>CD3</td> <td>Repeated <I>cv-qualifier</I>s in declarators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1529"> <td><a href="https://cplusplus.github.io/CWG/issues/1529.html">1529</a></td> + <td>[<a href="https://wg21.link/basic.pre">basic.pre</a>]</td> <td>drafting</td> <td>Nomenclature for variable vs reference non-static data member</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1530"> <td><a href="https://cplusplus.github.io/CWG/issues/1530.html">1530</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>drafting</td> <td>Member access in out-of-lifetime objects</td> <td align="center">Not resolved</td> </tr> <tr id="1531"> <td><a href="https://cplusplus.github.io/CWG/issues/1531.html">1531</a></td> + <td>[<a href="https://wg21.link/intro.defs">intro.defs</a>]</td> <td>CD3</td> <td>Definition of “access” (verb)</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1532"> <td><a href="https://cplusplus.github.io/CWG/issues/1532.html">1532</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>CD3</td> <td>Explicit instantiation and member templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1533"> <td><a href="https://cplusplus.github.io/CWG/issues/1533.html">1533</a></td> + <td>[<a href="https://wg21.link/temp.variadic">temp.variadic</a>]</td> <td>CD3</td> <td>Function pack expansion for member initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1534"> <td><a href="https://cplusplus.github.io/CWG/issues/1534.html">1534</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>dup</td> <td>cv-qualification of prvalue of type “array of class”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1535"> <td><a href="https://cplusplus.github.io/CWG/issues/1535.html">1535</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td><TT>typeid</TT> in core constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1536"> <td><a href="https://cplusplus.github.io/CWG/issues/1536.html">1536</a></td> + <td>[<a href="https://wg21.link/over.ics.list">over.ics.list</a>]</td> <td>drafting</td> <td>Overload resolution with temporary from initializer list</td> <td align="center">Not resolved</td> </tr> <tr id="1537"> <td><a href="https://cplusplus.github.io/CWG/issues/1537.html">1537</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD3</td> <td>Optional compile-time evaluation of constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1538"> <td><a href="https://cplusplus.github.io/CWG/issues/1538.html">1538</a></td> + <td>[<a href="https://wg21.link/expr.assign">expr.assign</a>]</td> <td>CD3</td> <td>C-style cast in <I>braced-init-list</I> assignment</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1539"> <td><a href="https://cplusplus.github.io/CWG/issues/1539.html">1539</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>CD3</td> <td>Definition of “character type”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1540"> <td><a href="https://cplusplus.github.io/CWG/issues/1540.html">1540</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td>Use of address constants in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1541"> <td><a href="https://cplusplus.github.io/CWG/issues/1541.html">1541</a></td> + <td>[<a href="https://wg21.link/stmt.return">stmt.return</a>]</td> <td>CD3</td> <td><I>cv</I> <TT>void</TT> return types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1542"> <td><a href="https://cplusplus.github.io/CWG/issues/1542.html">1542</a></td> + <td>[<a href="https://wg21.link/expr.assign">expr.assign</a>]</td> <td>open</td> <td>Compound assignment of <I>braced-init-list</I></td> <td align="center">Not resolved</td> </tr> <tr id="1543"> <td><a href="https://cplusplus.github.io/CWG/issues/1543.html">1543</a></td> + <td>[<a href="https://wg21.link/over.ics.list">over.ics.list</a>]</td> <td>CD3</td> <td>Implicit conversion sequence for empty initializer list</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1544"> <td><a href="https://cplusplus.github.io/CWG/issues/1544.html">1544</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>CD3</td> <td>Linkage of member of unnamed namespace</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1545"> <td><a href="https://cplusplus.github.io/CWG/issues/1545.html">1545</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>NAD</td> <td><TT>friend</TT> function templates defined in class templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1546"> <td><a href="https://cplusplus.github.io/CWG/issues/1546.html">1546</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>NAD</td> <td>Errors in function template default arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1547"> <td><a href="https://cplusplus.github.io/CWG/issues/1547.html">1547</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>NAD</td> <td><TT>typename</TT> keyword in <I>alias-declaration</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1548"> <td><a href="https://cplusplus.github.io/CWG/issues/1548.html">1548</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>open</td> <td>Copy/move construction and conversion functions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1549"> <td><a href="https://cplusplus.github.io/CWG/issues/1549.html">1549</a></td> + <td>[<a href="https://wg21.link/over.binary">over.binary</a>]</td> <td>open</td> <td>Overloaded comma operator with <TT>void</TT> operand</td> <td align="center">Not resolved</td> </tr> <tr id="1550"> <td><a href="https://cplusplus.github.io/CWG/issues/1550.html">1550</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD3</td> <td>Parenthesized <I>throw-expression</I> operand of <I>conditional-expression</I></td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="1551"> <td><a href="https://cplusplus.github.io/CWG/issues/1551.html">1551</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>C++14</td> <td>Wording problems in <I>using-declaration</I> specification</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1552"> <td><a href="https://cplusplus.github.io/CWG/issues/1552.html">1552</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD4</td> <td><I>exception-specification</I>s and defaulted special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1553"> <td><a href="https://cplusplus.github.io/CWG/issues/1553.html">1553</a></td> + <td>[<a href="https://wg21.link/expr.sizeof">expr.sizeof</a>]</td> <td>CD3</td> <td><TT>sizeof</TT> and xvalue bit-fields</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1554"> <td><a href="https://cplusplus.github.io/CWG/issues/1554.html">1554</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>drafting</td> <td>Access and alias templates</td> <td align="center">Not resolved</td> </tr> <tr id="1555"> <td><a href="https://cplusplus.github.io/CWG/issues/1555.html">1555</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>NAD</td> <td>Language linkage and function type compatibility</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1556"> <td><a href="https://cplusplus.github.io/CWG/issues/1556.html">1556</a></td> + <td>[<a href="https://wg21.link/over.match.copy">over.match.copy</a>]</td> <td>CD3</td> <td>Constructors and explicit conversion functions in direct initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1557"> <td><a href="https://cplusplus.github.io/CWG/issues/1557.html">1557</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD3</td> <td>Language linkage of converted lambda function pointer</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1558"> <td><a href="https://cplusplus.github.io/CWG/issues/1558.html">1558</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>CD4</td> <td>Unused arguments in alias template specializations</td> <td class="full" align="center">Clang 12</td> </tr> <tr id="1559"> <td><a href="https://cplusplus.github.io/CWG/issues/1559.html">1559</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD3</td> <td>String too long in initializer list of <I>new-expression</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1560"> <td><a href="https://cplusplus.github.io/CWG/issues/1560.html">1560</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD3</td> <td>Gratuitous lvalue-to-rvalue conversion in <I>conditional-expression</I> with <I>throw-expression</I> operand</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="1561"> <td><a href="https://cplusplus.github.io/CWG/issues/1561.html">1561</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>CD4</td> <td>Aggregates with empty base classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1562"> <td><a href="https://cplusplus.github.io/CWG/issues/1562.html">1562</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>C++14</td> <td>Non-static data member initializers and union <I>ctor-initializer</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1563"> <td><a href="https://cplusplus.github.io/CWG/issues/1563.html">1563</a></td> + <td>[<a href="https://wg21.link/over.over">over.over</a>]</td> <td>CD3</td> <td>List-initialization and overloaded function disambiguation</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="1564"> <td><a href="https://cplusplus.github.io/CWG/issues/1564.html">1564</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>NAD</td> <td>Template argument deduction from an initializer list</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1565"> <td><a href="https://cplusplus.github.io/CWG/issues/1565.html">1565</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>NAD</td> <td>Copy elision and lifetime of <TT>initializer_list</TT> underlying array</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1566"> <td><a href="https://cplusplus.github.io/CWG/issues/1566.html">1566</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>NAD</td> <td>Should <TT>new std::initializer_list<T></TT> be ill-formed?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1567"> <td><a href="https://cplusplus.github.io/CWG/issues/1567.html">1567</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>C++14</td> <td>Inheriting constructors and copy/move constructors</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr id="1568"> <td><a href="https://cplusplus.github.io/CWG/issues/1568.html">1568</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>dup</td> <td>Temporary lifetime extension with intervening cast</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1569"> <td><a href="https://cplusplus.github.io/CWG/issues/1569.html">1569</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>C++14</td> <td>Deducing a function parameter pack before ellipsis</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1570"> <td><a href="https://cplusplus.github.io/CWG/issues/1570.html">1570</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>C++14</td> <td>Address of subobject as non-type template argument</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1571"> <td><a href="https://cplusplus.github.io/CWG/issues/1571.html">1571</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD4</td> <td>cv-qualification for indirect reference binding via conversion function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1572"> <td><a href="https://cplusplus.github.io/CWG/issues/1572.html">1572</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD4</td> <td>Incorrect example for rvalue reference binding via conversion function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1573"> <td><a href="https://cplusplus.github.io/CWG/issues/1573.html">1573</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>CD4</td> <td>Inherited constructor characteristics</td> <td class="full" align="center">Clang 3.9</td> </tr> <tr id="1574"> <td><a href="https://cplusplus.github.io/CWG/issues/1574.html">1574</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>NAD</td> <td>Explicitly-defaulted <TT>constexpr</TT> functions in wrapper templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1575"> <td><a href="https://cplusplus.github.io/CWG/issues/1575.html">1575</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.safety">basic.stc.dynamic.safety</a>]</td> <td>C++14</td> <td>Incorrect definition of “strict pointer safety”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1576"> <td><a href="https://cplusplus.github.io/CWG/issues/1576.html">1576</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>C++14</td> <td>Discarded-value volatile xvalues</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1577"> <td><a href="https://cplusplus.github.io/CWG/issues/1577.html">1577</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial.general">temp.spec.partial.general</a>]</td> <td>NAD</td> <td>Unnecessary restrictions on partial specializations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1578"> <td><a href="https://cplusplus.github.io/CWG/issues/1578.html">1578</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>NAD</td> <td>Value-initialization of aggregates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1579"> <td><a href="https://cplusplus.github.io/CWG/issues/1579.html">1579</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++14</td> <td>Return by converting move constructor</td> <td class="full" align="center">Clang 3.9</td> </tr> <tr class="open" id="1580"> <td><a href="https://cplusplus.github.io/CWG/issues/1580.html">1580</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>drafting</td> <td>Default arguments in explicit instantiations</td> <td align="center">Not resolved</td> </tr> <tr id="1581"> <td><a href="https://cplusplus.github.io/CWG/issues/1581.html">1581</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD5</td> <td>When are <TT>constexpr</TT> member functions defined?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1582"> <td><a href="https://cplusplus.github.io/CWG/issues/1582.html">1582</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>drafting</td> <td>Template default arguments and deduction failure</td> <td align="center">Not resolved</td> </tr> <tr id="1583"> <td><a href="https://cplusplus.github.io/CWG/issues/1583.html">1583</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>C++14</td> <td>Incorrect example of unspecified behavior</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1584"> <td><a href="https://cplusplus.github.io/CWG/issues/1584.html">1584</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>drafting</td> <td>Deducing function types from cv-qualified types</td> <td align="center"> @@ -9335,1836 +10877,2142 @@ and <I>POD class</I></td> </tr> <tr id="1585"> <td><a href="https://cplusplus.github.io/CWG/issues/1585.html">1585</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>NAD</td> <td>Value category of member access of rvalue reference member</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1586"> <td><a href="https://cplusplus.github.io/CWG/issues/1586.html">1586</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>NAD</td> <td>Naming a destructor via <TT>decltype</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1587"> <td><a href="https://cplusplus.github.io/CWG/issues/1587.html">1587</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++14</td> <td><TT>constexpr</TT> initialization and nested anonymous unions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1588"> <td><a href="https://cplusplus.github.io/CWG/issues/1588.html">1588</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD3</td> <td>Deducing cv-qualified <TT>auto</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1589"> <td><a href="https://cplusplus.github.io/CWG/issues/1589.html">1589</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>CD4</td> <td>Ambiguous ranking of list-initialization sequences</td> <td class="full" align="center">Clang 3.7 (C++11 onwards)</td> </tr> <tr id="1590"> <td><a href="https://cplusplus.github.io/CWG/issues/1590.html">1590</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD4</td> <td>Bypassing non-copy/move constructor copying</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1591"> <td><a href="https://cplusplus.github.io/CWG/issues/1591.html">1591</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>CD4</td> <td>Deducing array bound and element type from initializer list</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1592"> <td><a href="https://cplusplus.github.io/CWG/issues/1592.html">1592</a></td> + <td>[<a href="https://wg21.link/temp.arg.template">temp.arg.template</a>]</td> <td>C++14</td> <td>When do template parameters match?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1593"> <td><a href="https://cplusplus.github.io/CWG/issues/1593.html">1593</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++14</td> <td>“Parameter type” of special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1594"> <td><a href="https://cplusplus.github.io/CWG/issues/1594.html">1594</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>drafting</td> <td>Lazy declaration of special members vs overload errors</td> <td align="center">Not resolved</td> </tr> <tr id="1595"> <td><a href="https://cplusplus.github.io/CWG/issues/1595.html">1595</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++14</td> <td>Constructors “involved in” subobject initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1596"> <td><a href="https://cplusplus.github.io/CWG/issues/1596.html">1596</a></td> + <td>[<a href="https://wg21.link/expr.rel">expr.rel</a>]</td> <td>CD4</td> <td>Non-array objects as <TT>array[1]</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1597"> <td><a href="https://cplusplus.github.io/CWG/issues/1597.html">1597</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD3</td> <td>Misleading <TT>constexpr</TT> example</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1598"> <td><a href="https://cplusplus.github.io/CWG/issues/1598.html">1598</a></td> + <td>[<a href="https://wg21.link/expr.eq">expr.eq</a>]</td> <td>C++14</td> <td>Criterion for equality of pointers to members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1599"> <td><a href="https://cplusplus.github.io/CWG/issues/1599.html">1599</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD4</td> <td>Lifetime of <TT>initializer_list</TT> underlying array</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1600"> <td><a href="https://cplusplus.github.io/CWG/issues/1600.html">1600</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>CD4</td> <td>Erroneous reference initialization in example</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1601"> <td><a href="https://cplusplus.github.io/CWG/issues/1601.html">1601</a></td> + <td>[<a href="https://wg21.link/conv.prom">conv.prom</a>]</td> <td>C++14</td> <td>Promotion of enumeration with fixed underlying type</td> <td class="full" align="center">Clang 10</td> </tr> <tr class="open" id="1602"> <td><a href="https://cplusplus.github.io/CWG/issues/1602.html">1602</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>review</td> <td>Linkage of specialization vs linkage of template arguments</td> <td align="center">Not resolved</td> </tr> <tr id="1603"> <td><a href="https://cplusplus.github.io/CWG/issues/1603.html">1603</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD4</td> <td>Errors resulting from giving unnamed namespaces internal linkage</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1604"> <td><a href="https://cplusplus.github.io/CWG/issues/1604.html">1604</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>C++14</td> <td>Double temporaries in reference initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1605"> <td><a href="https://cplusplus.github.io/CWG/issues/1605.html">1605</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD3</td> <td>Misleading parenthetical comment for explicit destructor call</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1606"> <td><a href="https://cplusplus.github.io/CWG/issues/1606.html">1606</a></td> + <td>[<a href="https://wg21.link/expr.sizeof">expr.sizeof</a>]</td> <td>NAD</td> <td><TT>sizeof</TT> closure class</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="1607"> <td><a href="https://cplusplus.github.io/CWG/issues/1607.html">1607</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>C++14</td> <td>Lambdas in template parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1608"> <td><a href="https://cplusplus.github.io/CWG/issues/1608.html">1608</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>C++14</td> <td>Operator lookup in trailing return type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1609"> <td><a href="https://cplusplus.github.io/CWG/issues/1609.html">1609</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>open</td> <td>Default arguments and function parameter packs</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1610"> <td><a href="https://cplusplus.github.io/CWG/issues/1610.html">1610</a></td> + <td>[<a href="https://wg21.link/temp.deduct.partial">temp.deduct.partial</a>]</td> <td>drafting</td> <td>Cv-qualification in deduction of reference to array</td> <td align="center">Not resolved</td> </tr> <tr id="1611"> <td><a href="https://cplusplus.github.io/CWG/issues/1611.html">1611</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>C++14</td> <td>Deleted default constructor for abstract class</td> <td class="full" align="center">Duplicate of <a href="#1658">1658</a></td> </tr> <tr id="1612"> <td><a href="https://cplusplus.github.io/CWG/issues/1612.html">1612</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>C++14</td> <td>Implicit lambda capture and anonymous unions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1613"> <td><a href="https://cplusplus.github.io/CWG/issues/1613.html">1613</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>C++14</td> <td>Constant expressions and lambda capture</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1614"> <td><a href="https://cplusplus.github.io/CWG/issues/1614.html">1614</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD4</td> <td>Address of pure virtual function vs odr-use</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1615"> <td><a href="https://cplusplus.github.io/CWG/issues/1615.html">1615</a></td> + <td>[<a href="https://wg21.link/dcl.align">dcl.align</a>]</td> <td>CD4</td> <td>Alignment of types, variables, and members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1616"> <td><a href="https://cplusplus.github.io/CWG/issues/1616.html">1616</a></td> + <td>[<a href="https://wg21.link/stmt.ambig">stmt.ambig</a>]</td> <td>CD6</td> <td>Disambiguation parsing and template parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1617"> <td><a href="https://cplusplus.github.io/CWG/issues/1617.html">1617</a></td> + <td>[<a href="https://wg21.link/dcl.align">dcl.align</a>]</td> <td>open</td> <td><TT>alignas</TT> and non-defining declarations</td> <td align="center">Not resolved</td> </tr> <tr id="1618"> <td><a href="https://cplusplus.github.io/CWG/issues/1618.html">1618</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>C++14</td> <td>Gratuitously-unsigned underlying enum type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1619"> <td><a href="https://cplusplus.github.io/CWG/issues/1619.html">1619</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>open</td> <td>Definition of current instantiation</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1620"> <td><a href="https://cplusplus.github.io/CWG/issues/1620.html">1620</a></td> + <td>[<a href="https://wg21.link/over.literal">over.literal</a>]</td> <td>open</td> <td>User-defined literals and extended integer types</td> <td align="center">Not resolved</td> </tr> <tr id="1621"> <td><a href="https://cplusplus.github.io/CWG/issues/1621.html">1621</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>C++20</td> <td>Member initializers in anonymous unions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1622"> <td><a href="https://cplusplus.github.io/CWG/issues/1622.html">1622</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>C++17</td> <td>Empty aggregate initializer for union</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1623"> <td><a href="https://cplusplus.github.io/CWG/issues/1623.html">1623</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>drafting</td> <td>Deleted default union constructor and member initializers</td> <td align="center">Not resolved</td> </tr> <tr id="1624"> <td><a href="https://cplusplus.github.io/CWG/issues/1624.html">1624</a></td> + <td>[<a href="https://wg21.link/except.ctor">except.ctor</a>]</td> <td>NAD</td> <td>Destruction of union members with member initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1625"> <td><a href="https://cplusplus.github.io/CWG/issues/1625.html">1625</a></td> + <td>[<a href="https://wg21.link/cpp.stringize">cpp.stringize</a>]</td> <td>open</td> <td>Adding spaces between tokens in stringizing</td> <td align="center">Not resolved</td> </tr> <tr id="1626"> <td><a href="https://cplusplus.github.io/CWG/issues/1626.html">1626</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>dup</td> <td><TT>constexpr</TT> member functions in <I>brace-or-equal-initializer</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1627"> <td><a href="https://cplusplus.github.io/CWG/issues/1627.html">1627</a></td> + <td>[<a href="https://wg21.link/dcl.align">dcl.align</a>]</td> <td>NAD</td> <td>Agreement of dependent <TT>alignas</TT> specifiers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1628"> <td><a href="https://cplusplus.github.io/CWG/issues/1628.html">1628</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>open</td> <td>Deallocation function templates</td> <td align="center">Not resolved</td> </tr> <tr id="1629"> <td><a href="https://cplusplus.github.io/CWG/issues/1629.html">1629</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>C++14</td> <td>Can a closure class be a literal type?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1630"> <td><a href="https://cplusplus.github.io/CWG/issues/1630.html">1630</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD4</td> <td>Multiple default constructor templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1631"> <td><a href="https://cplusplus.github.io/CWG/issues/1631.html">1631</a></td> + <td>[<a href="https://wg21.link/over.ics.list">over.ics.list</a>]</td> <td>CD4</td> <td>Incorrect overload resolution for single-element <I>initializer-list</I></td> <td class="full" align="center">Clang 3.7</td> </tr> <tr id="1632"> <td><a href="https://cplusplus.github.io/CWG/issues/1632.html">1632</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD5</td> <td>Lambda capture in member initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1633"> <td><a href="https://cplusplus.github.io/CWG/issues/1633.html">1633</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD4</td> <td>Copy-initialization in member initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1634"> <td><a href="https://cplusplus.github.io/CWG/issues/1634.html">1634</a></td> + <td>[<a href="https://wg21.link/basic.stc">basic.stc</a>]</td> <td>open</td> <td>Temporary storage duration</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1635"> <td><a href="https://cplusplus.github.io/CWG/issues/1635.html">1635</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>drafting</td> <td>How similar are template default arguments to function default arguments?</td> <td align="center">Not resolved</td> </tr> <tr id="1636"> <td><a href="https://cplusplus.github.io/CWG/issues/1636.html">1636</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD5</td> <td>Bits required for negative enumerator values</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1637"> <td><a href="https://cplusplus.github.io/CWG/issues/1637.html">1637</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>NAD</td> <td>Recursion in <TT>constexpr</TT> template default constructor</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1638"> <td><a href="https://cplusplus.github.io/CWG/issues/1638.html">1638</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD4</td> <td>Declaring an explicit specialization of a scoped enumeration</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="1639"> <td><a href="https://cplusplus.github.io/CWG/issues/1639.html">1639</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD4</td> <td><I>exception-specification</I>s and pointer/pointer-to-member expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1640"> <td><a href="https://cplusplus.github.io/CWG/issues/1640.html">1640</a></td> + <td>[<a href="https://wg21.link/dcl.array">dcl.array</a>]</td> <td>CD5</td> <td>Array of abstract instance of class template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1641"> <td><a href="https://cplusplus.github.io/CWG/issues/1641.html">1641</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>NAD</td> <td>Assignment in member initializer</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1642"> <td><a href="https://cplusplus.github.io/CWG/issues/1642.html">1642</a></td> + <td>[<a href="https://wg21.link/expr.compound">expr.compound</a>]</td> <td>CD7</td> <td>Missing requirements for prvalue operands</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1643"> <td><a href="https://cplusplus.github.io/CWG/issues/1643.html">1643</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>NAD</td> <td>Default arguments for template parameter packs</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1644"> <td><a href="https://cplusplus.github.io/CWG/issues/1644.html">1644</a></td> + <td>[<a href="https://wg21.link/temp.over.link">temp.over.link</a>]</td> <td>NAD</td> <td>Equivalent <I>exception-specification</I>s in function template declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1645"> <td><a href="https://cplusplus.github.io/CWG/issues/1645.html">1645</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>CD4</td> <td>Identical inheriting constructors via default arguments</td> <td class="full" align="center">Clang 3.9</td> </tr> <tr id="1646"> <td><a href="https://cplusplus.github.io/CWG/issues/1646.html">1646</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD5</td> <td><I>decltype-specifier</I>s, abstract classes, and deduction failure</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1647"> <td><a href="https://cplusplus.github.io/CWG/issues/1647.html">1647</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial">temp.spec.partial</a>]</td> <td>drafting</td> <td>Type agreement of non-type template arguments in partial specializations</td> <td align="center">Not resolved</td> </tr> <tr id="1648"> <td><a href="https://cplusplus.github.io/CWG/issues/1648.html">1648</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>C++14</td> <td><TT>thread_local</TT> vs block extern declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1649"> <td><a href="https://cplusplus.github.io/CWG/issues/1649.html">1649</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>C++14</td> <td>Error in the syntax of <I>mem-initializer-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1650"> <td><a href="https://cplusplus.github.io/CWG/issues/1650.html">1650</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>NAD</td> <td>Class prvalues in reference initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1651"> <td><a href="https://cplusplus.github.io/CWG/issues/1651.html">1651</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>NAD</td> <td>Lifetime extension of temporary via reference to subobject</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1652"> <td><a href="https://cplusplus.github.io/CWG/issues/1652.html">1652</a></td> + <td>[<a href="https://wg21.link/expr.eq">expr.eq</a>]</td> <td>CD4</td> <td>Object addresses in <TT>constexpr</TT> expressions</td> <td class="full" align="center">Clang 3.6</td> </tr> <tr id="1653"> <td><a href="https://cplusplus.github.io/CWG/issues/1653.html">1653</a></td> + <td>[<a href="https://wg21.link/expr.pre.incr">expr.pre.incr</a>]</td> <td>CD4</td> <td>Removing deprecated increment of <TT>bool</TT></td> <td class="full" align="center">Clang 4 (C++17 onwards)</td> </tr> <tr id="1654"> <td><a href="https://cplusplus.github.io/CWG/issues/1654.html">1654</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>dup</td> <td>Literal types and <TT>constexpr</TT> defaulted constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1655"> <td><a href="https://cplusplus.github.io/CWG/issues/1655.html">1655</a></td> + <td>[<a href="https://wg21.link/lex.pptoken">lex.pptoken</a>]</td> <td>open</td> <td>Line endings in raw string literals</td> <td align="center">Not resolved</td> </tr> <tr id="1656"> <td><a href="https://cplusplus.github.io/CWG/issues/1656.html">1656</a></td> + <td>[<a href="https://wg21.link/lex.ccon">lex.ccon</a>]</td> <td>CD6</td> <td>Encoding of numerically-escaped characters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1657"> <td><a href="https://cplusplus.github.io/CWG/issues/1657.html">1657</a></td> + <td>[<a href="https://wg21.link/namespace.def">namespace.def</a>]</td> <td>CD4</td> <td>Attributes for namespaces and enumerators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1658"> <td><a href="https://cplusplus.github.io/CWG/issues/1658.html">1658</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>C++14</td> <td>Deleted default constructor for abstract class via destructor</td> <td class="full" align="center">Clang 5</td> </tr> <tr class="open" id="1659"> <td><a href="https://cplusplus.github.io/CWG/issues/1659.html">1659</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>open</td> <td>Initialization order of thread_local template static data members</td> <td align="center">Not resolved</td> </tr> <tr id="1660"> <td><a href="https://cplusplus.github.io/CWG/issues/1660.html">1660</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>C++14</td> <td><I>member-declaration</I> requirements and unnamed bit-fields</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1661"> <td><a href="https://cplusplus.github.io/CWG/issues/1661.html">1661</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>NAD</td> <td>Preservation of infinite loops</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1662"> <td><a href="https://cplusplus.github.io/CWG/issues/1662.html">1662</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>C++14</td> <td>Capturing function parameter packs</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1663"> <td><a href="https://cplusplus.github.io/CWG/issues/1663.html">1663</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>NAD</td> <td>Capturing an empty pack expansion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1664"> <td><a href="https://cplusplus.github.io/CWG/issues/1664.html">1664</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>C++14</td> <td>Argument-dependent lookup of lambdas used in default arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1665"> <td><a href="https://cplusplus.github.io/CWG/issues/1665.html">1665</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>drafting</td> <td>Declaration matching in explicit instantiations</td> <td align="center">Not resolved</td> </tr> <tr id="1666"> <td><a href="https://cplusplus.github.io/CWG/issues/1666.html">1666</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>C++14</td> <td>Address constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1667"> <td><a href="https://cplusplus.github.io/CWG/issues/1667.html">1667</a></td> + <td>[<a href="https://wg21.link/except.throw">except.throw</a>]</td> <td>NAD</td> <td>Function exiting via exception called by destructor during unwinding</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1668"> <td><a href="https://cplusplus.github.io/CWG/issues/1668.html">1668</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>drafting</td> <td>Parameter type determination still not clear enough</td> <td align="center">Not resolved</td> </tr> <tr id="1669"> <td><a href="https://cplusplus.github.io/CWG/issues/1669.html">1669</a></td> + <td>[<a href="https://wg21.link/basic.start.main">basic.start.main</a>]</td> <td>C++14</td> <td><TT>auto</TT> return type for <TT>main</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1670"> <td><a href="https://cplusplus.github.io/CWG/issues/1670.html">1670</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>review</td> <td><TT>auto</TT> as <I>conversion-type-id</I></td> <td align="center">Not resolved</td> </tr> <tr id="1671"> <td><a href="https://cplusplus.github.io/CWG/issues/1671.html">1671</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>NAD</td> <td>Unclear rules for deduction with cv-qualification</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1672"> <td><a href="https://cplusplus.github.io/CWG/issues/1672.html">1672</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD4</td> <td>Layout compatibility with multiple empty bases</td> <td class="full" align="center">Clang 7</td> </tr> <tr id="1673"> <td><a href="https://cplusplus.github.io/CWG/issues/1673.html">1673</a></td> + <td>[<a href="https://wg21.link/over.best.ics">over.best.ics</a>]</td> <td>C++14</td> <td>Clarifying overload resolution for the second step of copy-initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1674"> <td><a href="https://cplusplus.github.io/CWG/issues/1674.html">1674</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>C++14</td> <td>Return type deduction for address of function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1675"> <td><a href="https://cplusplus.github.io/CWG/issues/1675.html">1675</a></td> + <td>[<a href="https://wg21.link/implimits">implimits</a>]</td> <td>NAD</td> <td>Size limit for automatic array object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1676"> <td><a href="https://cplusplus.github.io/CWG/issues/1676.html">1676</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.allocation">basic.stc.dynamic.allocation</a>]</td> <td>drafting</td> <td><TT>auto</TT> return type for allocation and deallocation functions</td> <td align="center">Not resolved</td> </tr> <tr id="1677"> <td><a href="https://cplusplus.github.io/CWG/issues/1677.html">1677</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>C++17</td> <td>Constant initialization via aggregate initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1678"> <td><a href="https://cplusplus.github.io/CWG/issues/1678.html">1678</a></td> + <td>[<a href="https://wg21.link/expr.sizeof">expr.sizeof</a>]</td> <td>NAD</td> <td>Naming the type of an array of runtime bound</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1679"> <td><a href="https://cplusplus.github.io/CWG/issues/1679.html">1679</a></td> + <td>[<a href="https://wg21.link/stmt.ranged">stmt.ranged</a>]</td> <td>NAD</td> <td>Range-based <TT>for</TT> and array of runtime bound</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1680"> <td><a href="https://cplusplus.github.io/CWG/issues/1680.html">1680</a></td> + <td>[<a href="https://wg21.link/stmt.ranged">stmt.ranged</a>]</td> <td>drafting</td> <td>Including <TT><initializer_list></TT> for range-based <TT>for</TT></td> <td align="center">Not resolved</td> </tr> <tr id="1681"> <td><a href="https://cplusplus.github.io/CWG/issues/1681.html">1681</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>C++14</td> <td><I>init-capture</I>s and nested lambdas</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1682"> <td><a href="https://cplusplus.github.io/CWG/issues/1682.html">1682</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.allocation">basic.stc.dynamic.allocation</a>]</td> <td>open</td> <td>Overly-restrictive rules on function templates as allocation functions</td> <td align="center">Not resolved</td> </tr> <tr id="1683"> <td><a href="https://cplusplus.github.io/CWG/issues/1683.html">1683</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD4</td> <td>Incorrect example after <TT>constexpr</TT> changes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1684"> <td><a href="https://cplusplus.github.io/CWG/issues/1684.html">1684</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++14</td> <td>Static <TT>constexpr</TT> member functions for non-literal classes</td> <td class="full" align="center">Clang 3.6</td> </tr> <tr id="1685"> <td><a href="https://cplusplus.github.io/CWG/issues/1685.html">1685</a></td> + <td>[<a href="https://wg21.link/expr.unary.noexcept">expr.unary.noexcept</a>]</td> <td>NAD</td> <td>Value category of <TT>noexcept</TT> expression</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1686"> <td><a href="https://cplusplus.github.io/CWG/issues/1686.html">1686</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD4</td> <td>Which variables are “explicitly declared <TT>const</TT>?”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1687"> <td><a href="https://cplusplus.github.io/CWG/issues/1687.html">1687</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>C++14</td> <td>Conversions of operands of built-in operators</td> <td class="full" align="center">Clang 7</td> </tr> <tr id="1688"> <td><a href="https://cplusplus.github.io/CWG/issues/1688.html">1688</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>NAD</td> <td>Volatile <TT>constexpr</TT> variables</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1689"> <td><a href="https://cplusplus.github.io/CWG/issues/1689.html">1689</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>C++14</td> <td>Syntactic nonterminal for operand of <TT>alignas</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1690"> <td><a href="https://cplusplus.github.io/CWG/issues/1690.html">1690</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>C++14</td> <td>Associated namespace for local type</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="1691"> <td><a href="https://cplusplus.github.io/CWG/issues/1691.html">1691</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>C++14</td> <td>Argument-dependent lookup and opaque enumerations</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="1692"> <td><a href="https://cplusplus.github.io/CWG/issues/1692.html">1692</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>C++14</td> <td>Associated namespaces of doubly-nested classes</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="1693"> <td><a href="https://cplusplus.github.io/CWG/issues/1693.html">1693</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>C++14</td> <td>Superfluous semicolons in class definitions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1694"> <td><a href="https://cplusplus.github.io/CWG/issues/1694.html">1694</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD4</td> <td>Restriction on reference to temporary as a constant expression</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1695"> <td><a href="https://cplusplus.github.io/CWG/issues/1695.html">1695</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>NAD</td> <td>Lifetime extension via <I>init-capture</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1696"> <td><a href="https://cplusplus.github.io/CWG/issues/1696.html">1696</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD4</td> <td>Temporary lifetime and non-static data member initializers</td> <td class="full" align="center">Clang 7</td> </tr> <tr id="1697"> <td><a href="https://cplusplus.github.io/CWG/issues/1697.html">1697</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD4</td> <td>Lifetime extension and copy elision</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1698"> <td><a href="https://cplusplus.github.io/CWG/issues/1698.html">1698</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>CD7</td> <td>Files ending in <TT>\</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1699"> <td><a href="https://cplusplus.github.io/CWG/issues/1699.html">1699</a></td> + <td>[<a href="https://wg21.link/class.friend">class.friend</a>]</td> <td>open</td> <td>Does befriending a class befriend its friends?</td> <td align="center">Not resolved</td> </tr> <tr id="1700"> <td><a href="https://cplusplus.github.io/CWG/issues/1700.html">1700</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>NAD</td> <td>Does the special rvalue-reference deduction apply to alias templates?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1701"> <td><a href="https://cplusplus.github.io/CWG/issues/1701.html">1701</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>open</td> <td>Array vs sequence in object representation</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1702"> <td><a href="https://cplusplus.github.io/CWG/issues/1702.html">1702</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>drafting</td> <td>Rephrasing the definition of “anonymous union”</td> <td align="center">Not resolved</td> </tr> <tr id="1703"> <td><a href="https://cplusplus.github.io/CWG/issues/1703.html">1703</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>NAD</td> <td>Language linkage of names of functions with internal linkage</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1704"> <td><a href="https://cplusplus.github.io/CWG/issues/1704.html">1704</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>CD5</td> <td>Type checking in explicit instantiation of variable templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1705"> <td><a href="https://cplusplus.github.io/CWG/issues/1705.html">1705</a></td> + <td>[<a href="https://wg21.link/temp.deduct.partial">temp.deduct.partial</a>]</td> <td>CD4</td> <td>Unclear specification of “more specialized”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1706"> <td><a href="https://cplusplus.github.io/CWG/issues/1706.html">1706</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>drafting</td> <td><TT>alignas</TT> pack expansion syntax</td> <td align="center">Not resolved</td> </tr> <tr id="1707"> <td><a href="https://cplusplus.github.io/CWG/issues/1707.html">1707</a></td> + <td>[<a href="https://wg21.link/dcl.type.elab">dcl.type.elab</a>]</td> <td>C++14</td> <td><TT>template</TT> in <I>elaborated-type-specifier</I> without <I>nested-name-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1708"> <td><a href="https://cplusplus.github.io/CWG/issues/1708.html">1708</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>CD4</td> <td>overly-strict requirements for names with C language linkage</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1709"> <td><a href="https://cplusplus.github.io/CWG/issues/1709.html">1709</a></td> + <td>[<a href="https://wg21.link/cpp.stringize">cpp.stringize</a>]</td> <td>open</td> <td>Stringizing raw string literals containing newline</td> <td align="center">Not resolved</td> </tr> <tr id="1710"> <td><a href="https://cplusplus.github.io/CWG/issues/1710.html">1710</a></td> + <td>[<a href="https://wg21.link/class.derived">class.derived</a>]</td> <td>C++17</td> <td>Missing <TT>template</TT> keyword in <I>class-or-decltype</I></td> <td class="none" align="center">No</td> </tr> <tr id="1711"> <td><a href="https://cplusplus.github.io/CWG/issues/1711.html">1711</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial">temp.spec.partial</a>]</td> <td>CD6</td> <td>Missing specification of variable template partial specializations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1712"> <td><a href="https://cplusplus.github.io/CWG/issues/1712.html">1712</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD4</td> <td><TT>constexpr</TT> variable template declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1713"> <td><a href="https://cplusplus.github.io/CWG/issues/1713.html">1713</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>dup</td> <td>Linkage of variable template specializations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1714"> <td><a href="https://cplusplus.github.io/CWG/issues/1714.html">1714</a></td> + <td>[<a href="https://wg21.link/class.local">class.local</a>]</td> <td>NAD</td> <td>odr-use of <TT>this</TT> from a local class</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1715"> <td><a href="https://cplusplus.github.io/CWG/issues/1715.html">1715</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>CD4</td> <td>Access and inherited constructor templates</td> <td class="full" align="center">Clang 3.9</td> </tr> <tr id="1716"> <td><a href="https://cplusplus.github.io/CWG/issues/1716.html">1716</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>C++14</td> <td>When are default arguments evaluated?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1717"> <td><a href="https://cplusplus.github.io/CWG/issues/1717.html">1717</a></td> + <td>[<a href="https://wg21.link/lex.icon">lex.icon</a>]</td> <td>C++14</td> <td>Missing specification of type of binary literal</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1718"> <td><a href="https://cplusplus.github.io/CWG/issues/1718.html">1718</a></td> + <td>[<a href="https://wg21.link/cpp.replace">cpp.replace</a>]</td> <td>open</td> <td>Macro invocation spanning end-of-file</td> <td align="center">Not resolved</td> </tr> <tr id="1719"> <td><a href="https://cplusplus.github.io/CWG/issues/1719.html">1719</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD4</td> <td>Layout compatibility and cv-qualification revisited</td> <td class="full" align="center">Clang 19</td> </tr> <tr id="1720"> <td><a href="https://cplusplus.github.io/CWG/issues/1720.html">1720</a></td> + <td>[<a href="https://wg21.link/cpp.include">cpp.include</a>]</td> <td>NAD</td> <td>Macro invocation in <TT>#include</TT> directive</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1721"> <td><a href="https://cplusplus.github.io/CWG/issues/1721.html">1721</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>review</td> <td>Diagnosing ODR violations for static data members</td> <td align="center">Not resolved</td> </tr> <tr id="1722"> <td><a href="https://cplusplus.github.io/CWG/issues/1722.html">1722</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD4</td> <td>Should lambda to function pointer conversion function be <TT>noexcept</TT>?</td> <td class="full" align="center">Clang 9</td> </tr> <tr class="open" id="1723"> <td><a href="https://cplusplus.github.io/CWG/issues/1723.html">1723</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>open</td> <td>Multicharacter user-defined character literals</td> <td align="center">Not resolved</td> </tr> <tr id="1724"> <td><a href="https://cplusplus.github.io/CWG/issues/1724.html">1724</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD6</td> <td>Unclear rules for deduction failure</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1725"> <td><a href="https://cplusplus.github.io/CWG/issues/1725.html">1725</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>NAD</td> <td>Trailing return type with nested function declarator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1726"> <td><a href="https://cplusplus.github.io/CWG/issues/1726.html">1726</a></td> + <td>[<a href="https://wg21.link/class.conv.fct">class.conv.fct</a>]</td> <td>CD6</td> <td>Declarator operators and conversion function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1727"> <td><a href="https://cplusplus.github.io/CWG/issues/1727.html">1727</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>NAD</td> <td>Type of a specialization of a variable template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1728"> <td><a href="https://cplusplus.github.io/CWG/issues/1728.html">1728</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>CD5</td> <td>Type of an explicit instantiation of a variable template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1729"> <td><a href="https://cplusplus.github.io/CWG/issues/1729.html">1729</a></td> + <td>[<a href="https://wg21.link/temp.decls">temp.decls</a>]</td> <td>CD6</td> <td>Matching declarations and definitions of variable templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1730"> <td><a href="https://cplusplus.github.io/CWG/issues/1730.html">1730</a></td> + <td>[<a href="https://wg21.link/temp.decls">temp.decls</a>]</td> <td>drafting</td> <td>Can a variable template have an unnamed type?</td> <td align="center">Not resolved</td> </tr> <tr id="1731"> <td><a href="https://cplusplus.github.io/CWG/issues/1731.html">1731</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>NAD</td> <td><TT>is_trivially_</TT><I>X</I> and definitions of special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1732"> <td><a href="https://cplusplus.github.io/CWG/issues/1732.html">1732</a></td> + <td>[<a href="https://wg21.link/stmt.select">stmt.select</a>]</td> <td>C++14</td> <td>Defining types in <I>condition</I>s and range-based <TT>for</TT> statements</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1733"> <td><a href="https://cplusplus.github.io/CWG/issues/1733.html">1733</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD6</td> <td>Return type and value for <TT>operator=</TT> with <I>ref-qualifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1734"> <td><a href="https://cplusplus.github.io/CWG/issues/1734.html">1734</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD4</td> <td>Nontrivial deleted copy functions</td> <td class="none" align="center">No</td> </tr> <tr class="open" id="1735"> <td><a href="https://cplusplus.github.io/CWG/issues/1735.html">1735</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>open</td> <td>Out-of-range literals in <I>user-defined-literal</I>s</td> <td align="center">Not resolved</td> </tr> <tr id="1736"> <td><a href="https://cplusplus.github.io/CWG/issues/1736.html">1736</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>CD4</td> <td>Inheriting constructor templates in a local class</td> <td class="full" align="center">Clang 3.9</td> </tr> <tr id="1737"> <td><a href="https://cplusplus.github.io/CWG/issues/1737.html">1737</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>C++14</td> <td>Type dependence of call to a member of the current instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1738"> <td><a href="https://cplusplus.github.io/CWG/issues/1738.html">1738</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>C++14</td> <td>Explicit instantiation/specialization of inheriting constructor templates</td> <td class="na" align="center">Superseded by <a href="https://wg21.link/P0136R1">P0136R1</a></td> </tr> <tr id="1739"> <td><a href="https://cplusplus.github.io/CWG/issues/1739.html">1739</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>C++14</td> <td>Conversion of floating point to enumeration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1740"> <td><a href="https://cplusplus.github.io/CWG/issues/1740.html">1740</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>C++14</td> <td>Disambiguation of <TT>noexcept</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1741"> <td><a href="https://cplusplus.github.io/CWG/issues/1741.html">1741</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>C++14</td> <td>odr-use of class object in lvalue-to-rvalue conversion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1742"> <td><a href="https://cplusplus.github.io/CWG/issues/1742.html">1742</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD5</td> <td><I>using-declaration</I>s and scoped enumerators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1743"> <td><a href="https://cplusplus.github.io/CWG/issues/1743.html">1743</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>NAD</td> <td><I>init-capture</I>s in nested lambdas</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1744"> <td><a href="https://cplusplus.github.io/CWG/issues/1744.html">1744</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>CD4</td> <td>Unordered initialization for variable template specializations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1745"> <td><a href="https://cplusplus.github.io/CWG/issues/1745.html">1745</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>NAD</td> <td><TT>thread_local constexpr</TT> variable</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1746"> <td><a href="https://cplusplus.github.io/CWG/issues/1746.html">1746</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>C++14</td> <td>Are volatile scalar types trivially copyable?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1747"> <td><a href="https://cplusplus.github.io/CWG/issues/1747.html">1747</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>C++14</td> <td>Constant initialization of reference to function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1748"> <td><a href="https://cplusplus.github.io/CWG/issues/1748.html">1748</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD4</td> <td>Placement new with a null pointer</td> <td class="full" align="center">Clang 3.7</td> </tr> <tr id="1749"> <td><a href="https://cplusplus.github.io/CWG/issues/1749.html">1749</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>NAD</td> <td>Confusing definition for constant initializer</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1750"> <td><a href="https://cplusplus.github.io/CWG/issues/1750.html">1750</a></td> + <td>[<a href="https://wg21.link/over.match.copy">over.match.copy</a>]</td> <td>CD4</td> <td>“Argument” vs “parameter”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1751"> <td><a href="https://cplusplus.github.io/CWG/issues/1751.html">1751</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD4</td> <td>Non-trivial operations vs non-trivial initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1752"> <td><a href="https://cplusplus.github.io/CWG/issues/1752.html">1752</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>CD4</td> <td>Right-recursion in <I>mem-initializer-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1753"> <td><a href="https://cplusplus.github.io/CWG/issues/1753.html">1753</a></td> + <td>[<a href="https://wg21.link/basic.lookup.qual">basic.lookup.qual</a>]</td> <td>CD4</td> <td><I>decltype-specifier</I> in <I>nested-name-specifier</I> of destructor</td> <td class="full" align="center">Clang 11</td> </tr> <tr id="1754"> <td><a href="https://cplusplus.github.io/CWG/issues/1754.html">1754</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial">temp.spec.partial</a>]</td> <td>NAD</td> <td>Declaration of partial specialization of static data member template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1755"> <td><a href="https://cplusplus.github.io/CWG/issues/1755.html">1755</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial.member">temp.spec.partial.member</a>]</td> <td>drafting</td> <td>Out-of-class partial specializations of member templates</td> <td align="center">Not resolved</td> </tr> <tr id="1756"> <td><a href="https://cplusplus.github.io/CWG/issues/1756.html">1756</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD4</td> <td>Direct-list-initialization of a non-class object</td> <td class="full" align="center">Clang 3.7</td> </tr> <tr id="1757"> <td><a href="https://cplusplus.github.io/CWG/issues/1757.html">1757</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD4</td> <td>Const integral subobjects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1758"> <td><a href="https://cplusplus.github.io/CWG/issues/1758.html">1758</a></td> + <td>[<a href="https://wg21.link/over.match.list">over.match.list</a>]</td> <td>CD4</td> <td>Explicit conversion in copy/move list initialization</td> <td class="full" align="center">Clang 3.7</td> </tr> <tr id="1759"> <td><a href="https://cplusplus.github.io/CWG/issues/1759.html">1759</a></td> + <td>[<a href="https://wg21.link/lex.string">lex.string</a>]</td> <td>C++14</td> <td>UTF-8 code units in plain <TT>char</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1760"> <td><a href="https://cplusplus.github.io/CWG/issues/1760.html">1760</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>C++14</td> <td>Access of member corresponding to <I>init-capture</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1761"> <td><a href="https://cplusplus.github.io/CWG/issues/1761.html">1761</a></td> + <td>[<a href="https://wg21.link/dcl.array">dcl.array</a>]</td> <td>NAD</td> <td>Runtime check on size of automatic array</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1762"> <td><a href="https://cplusplus.github.io/CWG/issues/1762.html">1762</a></td> + <td>[<a href="https://wg21.link/over.literal">over.literal</a>]</td> <td>C++14</td> <td>Reserved identifier used in <I>literal-operator-id</I> example</td> <td class="full" align="center">Clang 14</td> </tr> <tr class="open" id="1763"> <td><a href="https://cplusplus.github.io/CWG/issues/1763.html">1763</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>open</td> <td>Length mismatch in template type deduction</td> <td align="center">Not resolved</td> </tr> <tr id="1764"> <td><a href="https://cplusplus.github.io/CWG/issues/1764.html">1764</a></td> + <td>[<a href="https://wg21.link/class.member.lookup">class.member.lookup</a>]</td> <td>C++14</td> <td>Hiding of function from using-declaration by signature</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1765"> <td><a href="https://cplusplus.github.io/CWG/issues/1765.html">1765</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>C++14</td> <td>Overflow of enumeration used as enumerator value</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1766"> <td><a href="https://cplusplus.github.io/CWG/issues/1766.html">1766</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD4</td> <td>Values outside the range of the values of an enumeration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1767"> <td><a href="https://cplusplus.github.io/CWG/issues/1767.html">1767</a></td> + <td>[<a href="https://wg21.link/stmt.switch">stmt.switch</a>]</td> <td>C++14</td> <td>Scoped enumeration in a <TT>switch</TT> statement</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1768"> <td><a href="https://cplusplus.github.io/CWG/issues/1768.html">1768</a></td> + <td>[<a href="https://wg21.link/dcl.array">dcl.array</a>]</td> <td>NAD</td> <td>Zero-element array of runtime bound</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1769"> <td><a href="https://cplusplus.github.io/CWG/issues/1769.html">1769</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>C++14</td> <td>Catching a base class of the exception object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1770"> <td><a href="https://cplusplus.github.io/CWG/issues/1770.html">1770</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>C++14</td> <td>Type matching of non-type template parameters and arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1771"> <td><a href="https://cplusplus.github.io/CWG/issues/1771.html">1771</a></td> + <td>[<a href="https://wg21.link/basic.lookup.qual">basic.lookup.qual</a>]</td> <td>CD6</td> <td>Restricted lookup in <I>nested-name-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1772"> <td><a href="https://cplusplus.github.io/CWG/issues/1772.html">1772</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>C++14</td> <td><TT>__func__</TT> in a lambda body</td> <td class="full" align="center">Clang 14</td> </tr> <tr id="1773"> <td><a href="https://cplusplus.github.io/CWG/issues/1773.html">1773</a></td> + <td>[<a href="https://wg21.link/conv.lval">conv.lval</a>]</td> <td>C++14</td> <td>Out-of-lifetime lvalue-to-rvalue conversion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1774"> <td><a href="https://cplusplus.github.io/CWG/issues/1774.html">1774</a></td> + <td>[<a href="https://wg21.link/except.ctor">except.ctor</a>]</td> <td>CD4</td> <td>Discrepancy between subobject destruction and stack unwinding</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1775"> <td><a href="https://cplusplus.github.io/CWG/issues/1775.html">1775</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>C++14</td> <td>Undefined behavior of line splice in raw string literal</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1776"> <td><a href="https://cplusplus.github.io/CWG/issues/1776.html">1776</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD4</td> <td>Replacement of class objects containing reference members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1777"> <td><a href="https://cplusplus.github.io/CWG/issues/1777.html">1777</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD4</td> <td>Empty pack expansion in <I>dynamic-exception-specification</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1778"> <td><a href="https://cplusplus.github.io/CWG/issues/1778.html">1778</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>C++14</td> <td><I>exception-specification</I> in explicitly-defaulted functions</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="1779"> <td><a href="https://cplusplus.github.io/CWG/issues/1779.html">1779</a></td> + <td>[<a href="https://wg21.link/temp.dep.expr">temp.dep.expr</a>]</td> <td>CD4</td> <td>Type dependency of <TT>__func__</TT></td> <td class="full" align="center">Clang 14</td> </tr> <tr id="1780"> <td><a href="https://cplusplus.github.io/CWG/issues/1780.html">1780</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD4</td> <td>Explicit instantiation/specialization of generic lambda <TT>operator()</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1781"> <td><a href="https://cplusplus.github.io/CWG/issues/1781.html">1781</a></td> + <td>[<a href="https://wg21.link/over.match.conv">over.match.conv</a>]</td> <td>CD5</td> <td>Converting from <TT>nullptr_t</TT> to <TT>bool</TT> in overload resolution</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1782"> <td><a href="https://cplusplus.github.io/CWG/issues/1782.html">1782</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>CD4</td> <td>Form of initialization for <TT>nullptr_t</TT> to <TT>bool</TT> conversion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1783"> <td><a href="https://cplusplus.github.io/CWG/issues/1783.html">1783</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>NAD</td> <td>Why are virtual destructors non-trivial?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1784"> <td><a href="https://cplusplus.github.io/CWG/issues/1784.html">1784</a></td> + <td>[<a href="https://wg21.link/stmt.dcl">stmt.dcl</a>]</td> <td>C++17</td> <td>Concurrent execution during static local initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1785"> <td><a href="https://cplusplus.github.io/CWG/issues/1785.html">1785</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>NAD</td> <td>Conflicting diagnostic requirements for template definitions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1786"> <td><a href="https://cplusplus.github.io/CWG/issues/1786.html">1786</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>C++14</td> <td>Effect of merging allocations on memory leakage</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1787"> <td><a href="https://cplusplus.github.io/CWG/issues/1787.html">1787</a></td> + <td>[<a href="https://wg21.link/conv.lval">conv.lval</a>]</td> <td>C++14</td> <td>Uninitialized <TT>unsigned char</TT> values</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1788"> <td><a href="https://cplusplus.github.io/CWG/issues/1788.html">1788</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>CD4</td> <td>Sized deallocation of array of non-class type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1789"> <td><a href="https://cplusplus.github.io/CWG/issues/1789.html">1789</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>open</td> <td>Array reference vs array decay in overload resolution</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1790"> <td><a href="https://cplusplus.github.io/CWG/issues/1790.html">1790</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>open</td> <td>Ellipsis following function parameter pack</td> <td align="center">Not resolved</td> </tr> <tr id="1791"> <td><a href="https://cplusplus.github.io/CWG/issues/1791.html">1791</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.general">dcl.fct.def.general</a>]</td> <td>CD4</td> <td>Incorrect restrictions on <I>cv-qualifier-seq</I> and <I>ref-qualifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1792"> <td><a href="https://cplusplus.github.io/CWG/issues/1792.html">1792</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>NAD</td> <td>Incorrect example of explicit specialization of member enumeration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1793"> <td><a href="https://cplusplus.github.io/CWG/issues/1793.html">1793</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>CD4</td> <td><TT>thread_local</TT> in explicit specializations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1794"> <td><a href="https://cplusplus.github.io/CWG/issues/1794.html">1794</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>C++17</td> <td><TT>template</TT> keyword and alias templates</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="1795"> <td><a href="https://cplusplus.github.io/CWG/issues/1795.html">1795</a></td> + <td>[<a href="https://wg21.link/namespace.def">namespace.def</a>]</td> <td>CD4</td> <td>Disambiguating <I>original-namespace-definition</I> and <I>extension-namespace-definition</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1796"> <td><a href="https://cplusplus.github.io/CWG/issues/1796.html">1796</a></td> + <td>[<a href="https://wg21.link/lex.charset">lex.charset</a>]</td> <td>CD4</td> <td>Is all-bits-zero for null characters a meaningful requirement?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1797"> <td><a href="https://cplusplus.github.io/CWG/issues/1797.html">1797</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>CD4</td> <td>Are all bit patterns of <TT>unsigned char</TT> distinct numbers?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1798"> <td><a href="https://cplusplus.github.io/CWG/issues/1798.html">1798</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>NAD</td> <td><I>exception-specification</I>s of template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1799"> <td><a href="https://cplusplus.github.io/CWG/issues/1799.html">1799</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>CD4</td> <td><TT>mutable</TT> and non-explicit const qualification</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1800"> <td><a href="https://cplusplus.github.io/CWG/issues/1800.html">1800</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>CD4</td> <td>Pointer to member of nested anonymous union</td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="1801"> <td><a href="https://cplusplus.github.io/CWG/issues/1801.html">1801</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>CD4</td> <td>Kind of expression referring to member of anonymous union</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="1802"> <td><a href="https://cplusplus.github.io/CWG/issues/1802.html">1802</a></td> + <td>[<a href="https://wg21.link/lex.string">lex.string</a>]</td> <td>CD4</td> <td><TT>char16_t</TT> string literals and surrogate pairs</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="1803"> <td><a href="https://cplusplus.github.io/CWG/issues/1803.html">1803</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD5</td> <td><I>opaque-enum-declaration</I> as <I>member-declaration</I></td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="1804"> <td><a href="https://cplusplus.github.io/CWG/issues/1804.html">1804</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>CD4</td> <td>Partial specialization and friendship</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="1805"> <td><a href="https://cplusplus.github.io/CWG/issues/1805.html">1805</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD4</td> <td>Conversions of array operands in <I>conditional-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1806"> <td><a href="https://cplusplus.github.io/CWG/issues/1806.html">1806</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>CD4</td> <td>Virtual bases and move-assignment</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1807"> <td><a href="https://cplusplus.github.io/CWG/issues/1807.html">1807</a></td> + <td>[<a href="https://wg21.link/except.ctor">except.ctor</a>]</td> <td>CD4</td> <td>Order of destruction of array elements after an exception</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr class="open" id="1808"> <td><a href="https://cplusplus.github.io/CWG/issues/1808.html">1808</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>drafting</td> <td>Constructor templates vs default constructors</td> <td align="center">Not resolved</td> </tr> <tr id="1809"> <td><a href="https://cplusplus.github.io/CWG/issues/1809.html">1809</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD4</td> <td>Narrowing and template argument deduction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1810"> <td><a href="https://cplusplus.github.io/CWG/issues/1810.html">1810</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>CD4</td> <td>Invalid <I>ud-suffix</I>es</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1811"> <td><a href="https://cplusplus.github.io/CWG/issues/1811.html">1811</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD4</td> <td>Lookup of deallocation function in a virtual destructor definition</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1812"> <td><a href="https://cplusplus.github.io/CWG/issues/1812.html">1812</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>C++17</td> <td>Omission of <TT>template</TT> in a <I>typename-specifier</I></td> <td class="none" align="center">No</td> </tr> <tr id="1813"> <td><a href="https://cplusplus.github.io/CWG/issues/1813.html">1813</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD4</td> <td>Direct vs indirect bases in standard-layout classes</td> <td class="full" align="center">Clang 7</td> </tr> <tr id="1814"> <td><a href="https://cplusplus.github.io/CWG/issues/1814.html">1814</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>CD4</td> <td>Default arguments in <I>lambda-expression</I>s</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="1815"> <td><a href="https://cplusplus.github.io/CWG/issues/1815.html">1815</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>CD4</td> <td>Lifetime extension in aggregate initialization</td> <td class="full" align="center">Clang 20</td> </tr> <tr id="1816"> <td><a href="https://cplusplus.github.io/CWG/issues/1816.html">1816</a></td> + <td>[<a href="https://wg21.link/conv.integral">conv.integral</a>]</td> <td>CD4</td> <td>Unclear specification of bit-field values</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1817"> <td><a href="https://cplusplus.github.io/CWG/issues/1817.html">1817</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>open</td> <td>Linkage specifications and nested scopes</td> <td align="center">Not resolved</td> </tr> <tr id="1818"> <td><a href="https://cplusplus.github.io/CWG/issues/1818.html">1818</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>CD6</td> <td>Visibility and inherited language linkage</td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="1819"> <td><a href="https://cplusplus.github.io/CWG/issues/1819.html">1819</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial.general">temp.spec.partial.general</a>]</td> <td>CD4</td> <td>Acceptable scopes for definition of partial specialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1820"> <td><a href="https://cplusplus.github.io/CWG/issues/1820.html">1820</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>CD6</td> <td>Qualified typedef names</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="1821"> <td><a href="https://cplusplus.github.io/CWG/issues/1821.html">1821</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD6</td> <td>Qualified redeclarations in a class <I>member-specification</I></td> <td class="full" align="center">Clang 2.9</td> </tr> <tr id="1822"> <td><a href="https://cplusplus.github.io/CWG/issues/1822.html">1822</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD6</td> <td>Lookup of parameter names in <I>lambda-expression</I>s</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="1823"> <td><a href="https://cplusplus.github.io/CWG/issues/1823.html">1823</a></td> + <td>[<a href="https://wg21.link/dcl.fct.spec">dcl.fct.spec</a>]</td> <td>CD4</td> <td>String literal uniqueness in inline functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1824"> <td><a href="https://cplusplus.github.io/CWG/issues/1824.html">1824</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD4</td> <td>Completeness of return type vs point of instantiation</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="1825"> <td><a href="https://cplusplus.github.io/CWG/issues/1825.html">1825</a></td> + <td>[<a href="https://wg21.link/temp.deduct.partial">temp.deduct.partial</a>]</td> <td>C++17</td> <td>Partial ordering between variadic and non-variadic function templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1826"> <td><a href="https://cplusplus.github.io/CWG/issues/1826.html">1826</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td><TT>const</TT> floating-point in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1827"> <td><a href="https://cplusplus.github.io/CWG/issues/1827.html">1827</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>drafting</td> <td>Reference binding with ambiguous conversions</td> <td align="center">Not resolved</td> </tr> <tr id="1828"> <td><a href="https://cplusplus.github.io/CWG/issues/1828.html">1828</a></td> + <td>[<a href="https://wg21.link/basic.lookup.qual">basic.lookup.qual</a>]</td> <td>CD6</td> <td><I>nested-name-specifier</I> ambiguity</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1829"> <td><a href="https://cplusplus.github.io/CWG/issues/1829.html">1829</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>CD6</td> <td>Dependent unnamed types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1830"> <td><a href="https://cplusplus.github.io/CWG/issues/1830.html">1830</a></td> + <td>[<a href="https://wg21.link/dcl.pre">dcl.pre</a>]</td> <td>CD4</td> <td>Repeated specifiers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1831"> <td><a href="https://cplusplus.github.io/CWG/issues/1831.html">1831</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>NAD</td> <td>Explicitly vs implicitly deleted move constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1832"> <td><a href="https://cplusplus.github.io/CWG/issues/1832.html">1832</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD4</td> <td>Casting to incomplete enumeration</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="1833"> <td><a href="https://cplusplus.github.io/CWG/issues/1833.html">1833</a></td> + <td>[<a href="https://wg21.link/class.friend">class.friend</a>]</td> <td>NAD</td> <td><TT>friend</TT> declarations naming implicitly-declared member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1834"> <td><a href="https://cplusplus.github.io/CWG/issues/1834.html">1834</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>CD4</td> <td>Constant initialization binding a reference to an xvalue</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1835"> <td><a href="https://cplusplus.github.io/CWG/issues/1835.html">1835</a></td> + <td>[<a href="https://wg21.link/basic.lookup.classref">basic.lookup.classref</a>]</td> <td>CD6</td> <td>Dependent member lookup before <TT><</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1836"> <td><a href="https://cplusplus.github.io/CWG/issues/1836.html">1836</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>CD5</td> <td>Use of class type being defined in <I>trailing-return-type</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1837"> <td><a href="https://cplusplus.github.io/CWG/issues/1837.html">1837</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>CD6</td> <td>Use of <TT>this</TT> in <TT>friend</TT> and local class declarations</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr id="1838"> <td><a href="https://cplusplus.github.io/CWG/issues/1838.html">1838</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>CD4</td> <td>Definition via <I>unqualified-id</I> and <I>using-declaration</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1839"> <td><a href="https://cplusplus.github.io/CWG/issues/1839.html">1839</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD6</td> <td>Lookup of block-scope <TT>extern</TT> declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1840"> <td><a href="https://cplusplus.github.io/CWG/issues/1840.html">1840</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>drafting</td> <td>Non-deleted explicit specialization of deleted function template</td> <td align="center">Not resolved</td> </tr> <tr id="1841"> <td><a href="https://cplusplus.github.io/CWG/issues/1841.html">1841</a></td> + <td>[<a href="https://wg21.link/temp.local">temp.local</a>]</td> <td>CD6</td> <td><TT><</TT> following template injected-class-name</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1842"> <td><a href="https://cplusplus.github.io/CWG/issues/1842.html">1842</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>open</td> <td>Unevaluated operands and “carries a dependency”</td> <td align="center">Not resolved</td> </tr> <tr id="1843"> <td><a href="https://cplusplus.github.io/CWG/issues/1843.html">1843</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD4</td> <td>Bit-field in conditional operator with <TT>throw</TT> operand</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1844"> <td><a href="https://cplusplus.github.io/CWG/issues/1844.html">1844</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>open</td> <td>Defining “immediate context”</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1845"> <td><a href="https://cplusplus.github.io/CWG/issues/1845.html">1845</a></td> + <td>[<a href="https://wg21.link/temp.point">temp.point</a>]</td> <td>review</td> <td>Point of instantiation of a variable template specialization</td> <td align="center">Not resolved</td> </tr> <tr id="1846"> <td><a href="https://cplusplus.github.io/CWG/issues/1846.html">1846</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD4</td> <td>Declaring explicitly-defaulted implicitly-deleted functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1847"> <td><a href="https://cplusplus.github.io/CWG/issues/1847.html">1847</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>CD4</td> <td>Clarifying compatibility during partial ordering</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1848"> <td><a href="https://cplusplus.github.io/CWG/issues/1848.html">1848</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD4</td> <td>Parenthesized constructor and destructor declarators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1849"> <td><a href="https://cplusplus.github.io/CWG/issues/1849.html">1849</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD6</td> <td>Variable templates and the ODR</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1850"> <td><a href="https://cplusplus.github.io/CWG/issues/1850.html">1850</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>CD4</td> <td>Differences between definition context and point of instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1851"> <td><a href="https://cplusplus.github.io/CWG/issues/1851.html">1851</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD4</td> <td><TT>decltype(auto)</TT> in <I>new-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1852"> <td><a href="https://cplusplus.github.io/CWG/issues/1852.html">1852</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>CD4</td> <td>Wording issues regarding <TT>decltype(auto)</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1853"> <td><a href="https://cplusplus.github.io/CWG/issues/1853.html">1853</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>dup</td> <td>Defining “allocated storage”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1854"> <td><a href="https://cplusplus.github.io/CWG/issues/1854.html">1854</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>drafting</td> <td>Disallowing use of implicitly-deleted functions</td> <td align="center">Not resolved</td> </tr> <tr id="1855"> <td><a href="https://cplusplus.github.io/CWG/issues/1855.html">1855</a></td> + <td>[<a href="https://wg21.link/class.cdtor">class.cdtor</a>]</td> <td>dup</td> <td>Out-of-lifetime access to nonstatic data members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1856"> <td><a href="https://cplusplus.github.io/CWG/issues/1856.html">1856</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>open</td> <td>Indirect nested classes of class templates</td> <td align="center">Not resolved</td> </tr> <tr id="1857"> <td><a href="https://cplusplus.github.io/CWG/issues/1857.html">1857</a></td> + <td>[<a href="https://wg21.link/expr.shift">expr.shift</a>]</td> <td>CD5</td> <td>Additional questions about bits</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1858"> <td><a href="https://cplusplus.github.io/CWG/issues/1858.html">1858</a></td> + <td>[<a href="https://wg21.link/expr.eq">expr.eq</a>]</td> <td>CD4</td> <td>Comparing pointers to union members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1859"> <td><a href="https://cplusplus.github.io/CWG/issues/1859.html">1859</a></td> + <td>[<a href="https://wg21.link/lex.string">lex.string</a>]</td> <td>CD5</td> <td>UTF-16 in <TT>char16_t</TT> string literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1860"> <td><a href="https://cplusplus.github.io/CWG/issues/1860.html">1860</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>C++17</td> <td>What is a “direct member?”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1861"> <td><a href="https://cplusplus.github.io/CWG/issues/1861.html">1861</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>CD4</td> <td>Values of a bit-field</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1862"> <td><a href="https://cplusplus.github.io/CWG/issues/1862.html">1862</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>CD5</td> <td>Determining “corresponding members” for friendship</td> <td class="none" align="center">No</td> </tr> <tr id="1863"> <td><a href="https://cplusplus.github.io/CWG/issues/1863.html">1863</a></td> + <td>[<a href="https://wg21.link/except.throw">except.throw</a>]</td> <td>CD4</td> <td>Requirements on thrown object type to support <TT>std::current_exception()</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1864"> <td><a href="https://cplusplus.github.io/CWG/issues/1864.html">1864</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>NAD</td> <td>List-initialization of array objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1865"> <td><a href="https://cplusplus.github.io/CWG/issues/1865.html">1865</a></td> + <td>[<a href="https://wg21.link/expr.add">expr.add</a>]</td> <td>CD4</td> <td>Pointer arithmetic and multi-level qualification conversions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1866"> <td><a href="https://cplusplus.github.io/CWG/issues/1866.html">1866</a></td> + <td>[<a href="https://wg21.link/except.ctor">except.ctor</a>]</td> <td>CD4</td> <td>Initializing variant members with non-trivial destructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1867"> <td><a href="https://cplusplus.github.io/CWG/issues/1867.html">1867</a></td> + <td>[<a href="https://wg21.link/dcl.ambig.res">dcl.ambig.res</a>]</td> <td>NAD</td> <td>Function/expression ambiguity with qualified parameter name</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1868"> <td><a href="https://cplusplus.github.io/CWG/issues/1868.html">1868</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>open</td> <td>Meaning of “placeholder type”</td> <td align="center">Not resolved</td> </tr> <tr id="1869"> <td><a href="https://cplusplus.github.io/CWG/issues/1869.html">1869</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>NAD</td> <td><TT>thread_local</TT> vs <I>linkage-specification</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1870"> <td><a href="https://cplusplus.github.io/CWG/issues/1870.html">1870</a></td> + <td>[<a href="https://wg21.link/basic.def">basic.def</a>]</td> <td>CD4</td> <td>Contradictory wording about definitions vs explicit specialization/instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1871"> <td><a href="https://cplusplus.github.io/CWG/issues/1871.html">1871</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>NAD</td> <td>Non-identifier characters in <I>ud-suffix</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1872"> <td><a href="https://cplusplus.github.io/CWG/issues/1872.html">1872</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD4</td> <td>Instantiations of <TT>constexpr</TT> templates that cannot appear in constant expressions</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="1873"> <td><a href="https://cplusplus.github.io/CWG/issues/1873.html">1873</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>CD4</td> <td>Protected member access from derived class friends</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1874"> <td><a href="https://cplusplus.github.io/CWG/issues/1874.html">1874</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>CD4</td> <td>Type vs non-type template parameters with <TT>class</TT> keyword</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1875"> <td><a href="https://cplusplus.github.io/CWG/issues/1875.html">1875</a></td> + <td>[<a href="https://wg21.link/basic.scope.class">basic.scope.class</a>]</td> <td>CD4</td> <td>Reordering declarations in class scope</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1876"> <td><a href="https://cplusplus.github.io/CWG/issues/1876.html">1876</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>NAD</td> <td>Preventing explicit specialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1877"> <td><a href="https://cplusplus.github.io/CWG/issues/1877.html">1877</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD4</td> <td>Return type deduction from <TT>return</TT> with no operand</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1878"> <td><a href="https://cplusplus.github.io/CWG/issues/1878.html">1878</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD4</td> <td><TT>operator auto</TT> template</td> <td class="full" align="center">Clang 18</td> </tr> <tr id="1879"> <td><a href="https://cplusplus.github.io/CWG/issues/1879.html">1879</a></td> + <td>[<a href="https://wg21.link/basic.align">basic.align</a>]</td> <td>NAD</td> <td>Inadequate definition of alignment requirement</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1880"> <td><a href="https://cplusplus.github.io/CWG/issues/1880.html">1880</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD4</td> <td>When are parameter objects destroyed?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1881"> <td><a href="https://cplusplus.github.io/CWG/issues/1881.html">1881</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD4</td> <td>Standard-layout classes and unnamed bit-fields</td> <td class="full" align="center">Clang 7</td> </tr> <tr id="1882"> <td><a href="https://cplusplus.github.io/CWG/issues/1882.html">1882</a></td> + <td>[<a href="https://wg21.link/global.names">global.names</a>]</td> <td>CD4</td> <td>Reserved names without library use</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1883"> <td><a href="https://cplusplus.github.io/CWG/issues/1883.html">1883</a></td> + <td>[<a href="https://wg21.link/class.protected">class.protected</a>]</td> <td>review</td> <td>Protected access to constructors in <I>mem-initializer</I>s</td> <td align="center">Not resolved</td> </tr> <tr id="1884"> <td><a href="https://cplusplus.github.io/CWG/issues/1884.html">1884</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD6</td> <td>Unclear requirements for same-named external-linkage entities</td> <td class="partial" align="center">Partial</td> </tr> <tr id="1885"> <td><a href="https://cplusplus.github.io/CWG/issues/1885.html">1885</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD4</td> <td>Return value of a function is underspecified</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1886"> <td><a href="https://cplusplus.github.io/CWG/issues/1886.html">1886</a></td> + <td>[<a href="https://wg21.link/basic.start.main">basic.start.main</a>]</td> <td>CD4</td> <td>Language linkage for <TT>main()</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1887"> <td><a href="https://cplusplus.github.io/CWG/issues/1887.html">1887</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD4</td> <td>Problems with <TT>::</TT> as <I>nested-name-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1888"> <td><a href="https://cplusplus.github.io/CWG/issues/1888.html">1888</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>CD4</td> <td>Implicitly-declared default constructors and <TT>explicit</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1889"> <td><a href="https://cplusplus.github.io/CWG/issues/1889.html">1889</a></td> + <td>[<a href="https://wg21.link/cpp.pragma">cpp.pragma</a>]</td> <td>open</td> <td>Unclear effect of <TT>#pragma</TT> on conformance</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1890"> <td><a href="https://cplusplus.github.io/CWG/issues/1890.html">1890</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>drafting</td> <td>Member type depending on definition of member function</td> <td align="center"> @@ -11175,2670 +13023,3115 @@ and <I>POD class</I></td> </tr> <tr id="1891"> <td><a href="https://cplusplus.github.io/CWG/issues/1891.html">1891</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD4</td> <td>Move constructor/assignment for closure class</td> <td class="full" align="center">Clang 4</td> </tr> <tr id="1892"> <td><a href="https://cplusplus.github.io/CWG/issues/1892.html">1892</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD4</td> <td>Use of <TT>auto</TT> in function type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1893"> <td><a href="https://cplusplus.github.io/CWG/issues/1893.html">1893</a></td> + <td>[<a href="https://wg21.link/expr.type.conv">expr.type.conv</a>]</td> <td>CD5</td> <td>Function-style cast with <I>braced-init-list</I>s and empty pack expansions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1894"> <td><a href="https://cplusplus.github.io/CWG/issues/1894.html">1894</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>CD6</td> <td><I>typedef-name</I>s and <I>using-declaration</I>s</td> <td class="full" align="center">Clang 3.8</td> </tr> <tr id="1895"> <td><a href="https://cplusplus.github.io/CWG/issues/1895.html">1895</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD4</td> <td>Deleted conversions in conditional operator operands</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1896"> <td><a href="https://cplusplus.github.io/CWG/issues/1896.html">1896</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>CD6</td> <td>Repeated alias templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1897"> <td><a href="https://cplusplus.github.io/CWG/issues/1897.html">1897</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>review</td> <td>ODR vs alternative tokens</td> <td align="center">Not resolved</td> </tr> <tr id="1898"> <td><a href="https://cplusplus.github.io/CWG/issues/1898.html">1898</a></td> + <td>[<a href="https://wg21.link/over.dcl">over.dcl</a>]</td> <td>CD6</td> <td>Use of “equivalent” in overload resolution</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="1899"> <td><a href="https://cplusplus.github.io/CWG/issues/1899.html">1899</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>CD4</td> <td>Value-dependent constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1900"> <td><a href="https://cplusplus.github.io/CWG/issues/1900.html">1900</a></td> + <td>[<a href="https://wg21.link/dcl.meaning">dcl.meaning</a>]</td> <td>CD6</td> <td>Do <TT>friend</TT> declarations count as “previous declarations”?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="1901"> <td><a href="https://cplusplus.github.io/CWG/issues/1901.html">1901</a></td> + <td>[<a href="https://wg21.link/lex.token">lex.token</a>]</td> <td>open</td> <td><I>punctuator</I> referenced but not defined</td> <td align="center">Not resolved</td> </tr> <tr id="1902"> <td><a href="https://cplusplus.github.io/CWG/issues/1902.html">1902</a></td> + <td>[<a href="https://wg21.link/over.best.ics">over.best.ics</a>]</td> <td>CD4</td> <td>What makes a conversion “otherwise ill-formed”?</td> <td class="full" align="center">Clang 3.7</td> </tr> <tr id="1903"> <td><a href="https://cplusplus.github.io/CWG/issues/1903.html">1903</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD4</td> <td>What declarations are introduced by a non-member <I>using-declaration</I>?</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="1904"> <td><a href="https://cplusplus.github.io/CWG/issues/1904.html">1904</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>NAD</td> <td>Default template arguments for members of class templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1905"> <td><a href="https://cplusplus.github.io/CWG/issues/1905.html">1905</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>NAD</td> <td>Dependent types and injected-class-names</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1906"> <td><a href="https://cplusplus.github.io/CWG/issues/1906.html">1906</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>NAD</td> <td>Name lookup in member <TT>friend</TT> declaration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1907"> <td><a href="https://cplusplus.github.io/CWG/issues/1907.html">1907</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD6</td> <td><I>using-declaration</I>s and default arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1908"> <td><a href="https://cplusplus.github.io/CWG/issues/1908.html">1908</a></td> + <td>[<a href="https://wg21.link/basic.lookup.classref">basic.lookup.classref</a>]</td> <td>CD6</td> <td>Dual destructor lookup and <I>template-id</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1909"> <td><a href="https://cplusplus.github.io/CWG/issues/1909.html">1909</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD4</td> <td>Member class template with the same name as the class</td> <td class="full" align="center">Clang 3.7</td> </tr> <tr id="1910"> <td><a href="https://cplusplus.github.io/CWG/issues/1910.html">1910</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.allocation">basic.stc.dynamic.allocation</a>]</td> <td>CD5</td> <td>“Shall” requirement applied to runtime behavior</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1911"> <td><a href="https://cplusplus.github.io/CWG/issues/1911.html">1911</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD4</td> <td><TT>constexpr</TT> constructor with non-literal base class</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1912"> <td><a href="https://cplusplus.github.io/CWG/issues/1912.html">1912</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD5</td> <td><I>exception-specification</I> of defaulted function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1913"> <td><a href="https://cplusplus.github.io/CWG/issues/1913.html">1913</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD5</td> <td><TT>decltype((x))</TT> in <I>lambda-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1914"> <td><a href="https://cplusplus.github.io/CWG/issues/1914.html">1914</a></td> + <td>[<a href="https://wg21.link/dcl.attr">dcl.attr</a>]</td> <td>extension</td> <td>Duplicate standard attributes</td> <td align="center">Extension</td> </tr> <tr class="open" id="1915"> <td><a href="https://cplusplus.github.io/CWG/issues/1915.html">1915</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>open</td> <td>Potentially-invoked destructors in non-throwing constructors</td> <td align="center">Not resolved</td> </tr> <tr id="1916"> <td><a href="https://cplusplus.github.io/CWG/issues/1916.html">1916</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD4</td> <td>“Same cv-unqualified type”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1917"> <td><a href="https://cplusplus.github.io/CWG/issues/1917.html">1917</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>NAD</td> <td>decltype-qualified enumeration names</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1918"> <td><a href="https://cplusplus.github.io/CWG/issues/1918.html">1918</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>CD5</td> <td><TT>friend</TT> templates with dependent scopes</td> <td class="none" align="center">No</td> </tr> <tr class="open" id="1919"> <td><a href="https://cplusplus.github.io/CWG/issues/1919.html">1919</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>open</td> <td>Overload resolution for <TT>!</TT> with explicit conversion operator</td> <td align="center">Not resolved</td> </tr> <tr id="1920"> <td><a href="https://cplusplus.github.io/CWG/issues/1920.html">1920</a></td> + <td>[<a href="https://wg21.link/expr.pseudo">expr.pseudo</a>]</td> <td>CD4</td> <td>Qualification mismatch in <I>pseudo-destructor-name</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1921"> <td><a href="https://cplusplus.github.io/CWG/issues/1921.html">1921</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td><TT>constexpr</TT> constructors and point of initialization of <TT>const</TT> variables</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1922"> <td><a href="https://cplusplus.github.io/CWG/issues/1922.html">1922</a></td> + <td>[<a href="https://wg21.link/temp.local">temp.local</a>]</td> <td>CD4</td> <td>Injected class template names and default arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1923"> <td><a href="https://cplusplus.github.io/CWG/issues/1923.html">1923</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>NAD</td> <td>Lvalues of type <TT>void</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1924"> <td><a href="https://cplusplus.github.io/CWG/issues/1924.html">1924</a></td> + <td>[<a href="https://wg21.link/lex.literal">lex.literal</a>]</td> <td>review</td> <td>Definition of “literal” and kinds of literals</td> <td align="center">Not resolved</td> </tr> <tr id="1925"> <td><a href="https://cplusplus.github.io/CWG/issues/1925.html">1925</a></td> + <td>[<a href="https://wg21.link/expr.comma">expr.comma</a>]</td> <td>CD4</td> <td>Bit-field prvalues</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1926"> <td><a href="https://cplusplus.github.io/CWG/issues/1926.html">1926</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD4</td> <td>Potential results of subscript operator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1927"> <td><a href="https://cplusplus.github.io/CWG/issues/1927.html">1927</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>dup</td> <td>Lifetime of temporaries in <I>init-capture</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1928"> <td><a href="https://cplusplus.github.io/CWG/issues/1928.html">1928</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>NAD</td> <td>Triviality of deleted special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1929"> <td><a href="https://cplusplus.github.io/CWG/issues/1929.html">1929</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>CD4</td> <td><TT>template</TT> keyword following namespace <I>nested-name-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1930"> <td><a href="https://cplusplus.github.io/CWG/issues/1930.html">1930</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>CD4</td> <td><I>init-declarator-list</I> vs <I>member-declarator-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1931"> <td><a href="https://cplusplus.github.io/CWG/issues/1931.html">1931</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD5</td> <td>Default-constructible and copy-assignable closure types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1932"> <td><a href="https://cplusplus.github.io/CWG/issues/1932.html">1932</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD4</td> <td>Bit-field results of conditional operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1933"> <td><a href="https://cplusplus.github.io/CWG/issues/1933.html">1933</a></td> + <td>[<a href="https://wg21.link/implimits">implimits</a>]</td> <td>NAD</td> <td>Implementation limit for <I>initializer-list</I> elements</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1934"> <td><a href="https://cplusplus.github.io/CWG/issues/1934.html">1934</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>NAD</td> <td>Relaxing <I>exception-specification</I> compatibility requirements</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1935"> <td><a href="https://cplusplus.github.io/CWG/issues/1935.html">1935</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD5</td> <td>Reuse of placement arguments in deallocation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1936"> <td><a href="https://cplusplus.github.io/CWG/issues/1936.html">1936</a></td> + <td>[<a href="https://wg21.link/temp.dep">temp.dep</a>]</td> <td>CD6</td> <td>Dependent <I>qualified-id</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1937"> <td><a href="https://cplusplus.github.io/CWG/issues/1937.html">1937</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD5</td> <td>Incomplete specification of function pointer from lambda</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1938"> <td><a href="https://cplusplus.github.io/CWG/issues/1938.html">1938</a></td> + <td>[<a href="https://wg21.link/intro.compliance">intro.compliance</a>]</td> <td>CD5</td> <td>Should hosted/freestanding be implementation-defined?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1939"> <td><a href="https://cplusplus.github.io/CWG/issues/1939.html">1939</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>open</td> <td>Argument conversions to nondeduced parameter types revisited</td> <td align="center">Not resolved</td> </tr> <tr id="1940"> <td><a href="https://cplusplus.github.io/CWG/issues/1940.html">1940</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>CD4</td> <td><TT>static_assert</TT> in anonymous unions</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="1941"> <td><a href="https://cplusplus.github.io/CWG/issues/1941.html">1941</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>CD4</td> <td>SFINAE and inherited constructor default arguments</td> <td class="full" align="center">Clang 3.9</td> </tr> <tr id="1942"> <td><a href="https://cplusplus.github.io/CWG/issues/1942.html">1942</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>CD4</td> <td>Incorrect reference to <I>trailing-return-type</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1943"> <td><a href="https://cplusplus.github.io/CWG/issues/1943.html">1943</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>CD5</td> <td>Unspecified meaning of “bit”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1944"> <td><a href="https://cplusplus.github.io/CWG/issues/1944.html">1944</a></td> + <td>[<a href="https://wg21.link/diff">diff</a>]</td> <td>open</td> <td>New C incompatibilities</td> <td align="center">Not resolved</td> </tr> <tr id="1945"> <td><a href="https://cplusplus.github.io/CWG/issues/1945.html">1945</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>CD5</td> <td>Friend declarations naming members of class templates in non-templates</td> <td class="none" align="center">No</td> </tr> <tr id="1946"> <td><a href="https://cplusplus.github.io/CWG/issues/1946.html">1946</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD4</td> <td><I>exception-specification</I>s vs pointer dereference</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1947"> <td><a href="https://cplusplus.github.io/CWG/issues/1947.html">1947</a></td> + <td>[<a href="https://wg21.link/lex.icon">lex.icon</a>]</td> <td>NAD</td> <td>Digit separators following non-octal prefix</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="1948"> <td><a href="https://cplusplus.github.io/CWG/issues/1948.html">1948</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic">basic.stc.dynamic</a>]</td> <td>NAD</td> <td><I>exception-specification</I> of replacement global <TT>new</TT></td> <td class="full" align="center">Clang 3.5</td> </tr> <tr id="1949"> <td><a href="https://cplusplus.github.io/CWG/issues/1949.html">1949</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>CD4</td> <td>“sequenced after” instead of “sequenced before”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1950"> <td><a href="https://cplusplus.github.io/CWG/issues/1950.html">1950</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>NAD</td> <td>Restructuring description of ranks of conversion sequences</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1951"> <td><a href="https://cplusplus.github.io/CWG/issues/1951.html">1951</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>CD4</td> <td>Cv-qualification and literal types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1952"> <td><a href="https://cplusplus.github.io/CWG/issues/1952.html">1952</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD4</td> <td>Constant expressions and library undefined behavior</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1953"> <td><a href="https://cplusplus.github.io/CWG/issues/1953.html">1953</a></td> + <td>[<a href="https://wg21.link/intro.memory">intro.memory</a>]</td> <td>CD7</td> <td>Data races and common initial sequence</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1954"> <td><a href="https://cplusplus.github.io/CWG/issues/1954.html">1954</a></td> + <td>[<a href="https://wg21.link/expr.typeid">expr.typeid</a>]</td> <td>CD7</td> <td><TT>typeid</TT> null dereference check in subexpressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1955"> <td><a href="https://cplusplus.github.io/CWG/issues/1955.html">1955</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>CD4</td> <td><TT>#elif</TT> with invalid controlling expression</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1956"> <td><a href="https://cplusplus.github.io/CWG/issues/1956.html">1956</a></td> + <td>[<a href="https://wg21.link/basic.stc.auto">basic.stc.auto</a>]</td> <td>CD4</td> <td>Reuse of storage of automatic variables</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1957"> <td><a href="https://cplusplus.github.io/CWG/issues/1957.html">1957</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>NAD</td> <td><TT>decltype(auto)</TT> with direct-list-initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1958"> <td><a href="https://cplusplus.github.io/CWG/issues/1958.html">1958</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD4</td> <td><TT>decltype(auto)</TT> with parenthesized initializer</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1959"> <td><a href="https://cplusplus.github.io/CWG/issues/1959.html">1959</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>CD4</td> <td>Inadvertently inherited copy constructor</td> <td class="full" align="center">Clang 3.9</td> </tr> <tr id="1960"> <td><a href="https://cplusplus.github.io/CWG/issues/1960.html">1960</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>NAD</td> <td>Visibility of entity named in class-scope <I>using-declaration</I></td> <td class="none" align="center">No</td> </tr> <tr id="1961"> <td><a href="https://cplusplus.github.io/CWG/issues/1961.html">1961</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>C++17</td> <td>Potentially-concurrent actions within a signal handler</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1962"> <td><a href="https://cplusplus.github.io/CWG/issues/1962.html">1962</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.general">dcl.fct.def.general</a>]</td> <td>open</td> <td>Type of <TT>__func__</TT></td> <td align="center">Not resolved</td> </tr> <tr id="1963"> <td><a href="https://cplusplus.github.io/CWG/issues/1963.html">1963</a></td> + <td>[<a href="https://wg21.link/lex.name">lex.name</a>]</td> <td>CD4</td> <td>Implementation-defined identifier characters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1964"> <td><a href="https://cplusplus.github.io/CWG/issues/1964.html">1964</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>NAD</td> <td><I>opaque-enum-declaration</I> in <I>alias-declaration</I>?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1965"> <td><a href="https://cplusplus.github.io/CWG/issues/1965.html">1965</a></td> + <td>[<a href="https://wg21.link/expr.dynamic.cast">expr.dynamic.cast</a>]</td> <td>CD7</td> <td>Explicit casts to reference types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1966"> <td><a href="https://cplusplus.github.io/CWG/issues/1966.html">1966</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD4</td> <td>Colon following enumeration <I>elaborated-type-specifier</I></td> <td class="full" align="center">Clang 11</td> </tr> <tr id="1967"> <td><a href="https://cplusplus.github.io/CWG/issues/1967.html">1967</a></td> + <td>[<a href="https://wg21.link/class.copy.elision">class.copy.elision</a>]</td> <td>CD4</td> <td>Temporary lifetime and move-elision</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1968"> <td><a href="https://cplusplus.github.io/CWG/issues/1968.html">1968</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td>Address of <TT>typeid</TT> in constant expressions</td> <td class="none" align="center">No</td> </tr> <tr id="1969"> <td><a href="https://cplusplus.github.io/CWG/issues/1969.html">1969</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD6</td> <td>Missing exclusion of <TT>~S</TT> as an ordinary function name</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1970"> <td><a href="https://cplusplus.github.io/CWG/issues/1970.html">1970</a></td> + <td>[<a href="https://wg21.link/dcl.ambig.res">dcl.ambig.res</a>]</td> <td>NAD</td> <td>Ambiguity resolution for <TT>(T())*x</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1971"> <td><a href="https://cplusplus.github.io/CWG/issues/1971.html">1971</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>CD4</td> <td>Unclear disambiguation of destructor and <TT>operator~</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1972"> <td><a href="https://cplusplus.github.io/CWG/issues/1972.html">1972</a></td> + <td>[<a href="https://wg21.link/lex.name">lex.name</a>]</td> <td>CD6</td> <td>Identifier character restrictions in non-<I>identifier</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1973"> <td><a href="https://cplusplus.github.io/CWG/issues/1973.html">1973</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD7</td> <td>Which <I>parameter-declaration-clause</I> in a <I>lambda-expression</I>?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1974"> <td><a href="https://cplusplus.github.io/CWG/issues/1974.html">1974</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>NAD</td> <td>Redundant specification of non-type <I>typename-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1975"> <td><a href="https://cplusplus.github.io/CWG/issues/1975.html">1975</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD4</td> <td>Permissible declarations for <I>exception-specification</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1976"> <td><a href="https://cplusplus.github.io/CWG/issues/1976.html">1976</a></td> + <td>[<a href="https://wg21.link/namespace.alias">namespace.alias</a>]</td> <td>NAD</td> <td>Ambiguity of <I>namespace-alias</I>es</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1977"> <td><a href="https://cplusplus.github.io/CWG/issues/1977.html">1977</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>open</td> <td>Contradictory results of failed destructor lookup</td> <td align="center">Not resolved</td> </tr> <tr id="1978"> <td><a href="https://cplusplus.github.io/CWG/issues/1978.html">1978</a></td> + <td>[<a href="https://wg21.link/class.conv.ctor">class.conv.ctor</a>]</td> <td>CD4</td> <td>Redundant description of explicit constructor use</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1979"> <td><a href="https://cplusplus.github.io/CWG/issues/1979.html">1979</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>drafting</td> <td>Alias template specialization in template member definition</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="1980"> <td><a href="https://cplusplus.github.io/CWG/issues/1980.html">1980</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>drafting</td> <td>Equivalent but not functionally-equivalent redeclarations</td> <td align="center">Not resolved</td> </tr> <tr id="1981"> <td><a href="https://cplusplus.github.io/CWG/issues/1981.html">1981</a></td> + <td>[<a href="https://wg21.link/conv">conv</a>]</td> <td>CD4</td> <td>Implicit contextual conversions and <TT>explicit</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1982"> <td><a href="https://cplusplus.github.io/CWG/issues/1982.html">1982</a></td> + <td>[<a href="https://wg21.link/temp.arg.explicit">temp.arg.explicit</a>]</td> <td>NAD</td> <td>Deduction extending parameter pack</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1983"> <td><a href="https://cplusplus.github.io/CWG/issues/1983.html">1983</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD5</td> <td>Inappropriate use of <I>virt-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1984"> <td><a href="https://cplusplus.github.io/CWG/issues/1984.html">1984</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>NAD</td> <td>Lossless narrowing conversions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1985"> <td><a href="https://cplusplus.github.io/CWG/issues/1985.html">1985</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>NAD</td> <td>Unknown bound array member with <I>brace-or-equal-initializer</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1986"> <td><a href="https://cplusplus.github.io/CWG/issues/1986.html">1986</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>drafting</td> <td>odr-use and delayed initialization</td> <td align="center">Not resolved</td> </tr> <tr id="1987"> <td><a href="https://cplusplus.github.io/CWG/issues/1987.html">1987</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>NAD</td> <td><TT>constexpr</TT> static data members across translation units</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1988"> <td><a href="https://cplusplus.github.io/CWG/issues/1988.html">1988</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>CD4</td> <td>Ambiguity between dependent and non-dependent bases in implicit member access</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1989"> <td><a href="https://cplusplus.github.io/CWG/issues/1989.html">1989</a></td> + <td>[<a href="https://wg21.link/over.oper">over.oper</a>]</td> <td>drafting</td> <td>Insufficient restrictions on parameters of postfix operators</td> <td align="center">Not resolved</td> </tr> <tr id="1990"> <td><a href="https://cplusplus.github.io/CWG/issues/1990.html">1990</a></td> + <td>[<a href="https://wg21.link/dcl.pre">dcl.pre</a>]</td> <td>CD4</td> <td>Ambiguity due to optional <I>decl-specifier-seq</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1991"> <td><a href="https://cplusplus.github.io/CWG/issues/1991.html">1991</a></td> + <td>[<a href="https://wg21.link/class.inhctor">class.inhctor</a>]</td> <td>CD4</td> <td>Inheriting constructors vs default arguments</td> <td class="full" align="center">Clang 3.9</td> </tr> <tr id="1992"> <td><a href="https://cplusplus.github.io/CWG/issues/1992.html">1992</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD4</td> <td><TT>new (std::nothrow) int[N]</TT> can throw</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1993"> <td><a href="https://cplusplus.github.io/CWG/issues/1993.html">1993</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>open</td> <td>Use of <TT>template<></TT> defining member of explicit specialization</td> <td align="center">Not resolved</td> </tr> <tr id="1994"> <td><a href="https://cplusplus.github.io/CWG/issues/1994.html">1994</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>dup</td> <td>Confusing wording regarding multiple <TT>template<></TT> prefixes</td> <td class="unknown" align="center">Duplicate of <a href="#529">529</a></td> </tr> <tr id="1995"> <td><a href="https://cplusplus.github.io/CWG/issues/1995.html">1995</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD4</td> <td><I>exception-specification</I>s and non-type template parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="1996"> <td><a href="https://cplusplus.github.io/CWG/issues/1996.html">1996</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>drafting</td> <td>Reference list-initialization ignores conversion functions</td> <td align="center">Not resolved</td> </tr> <tr id="1997"> <td><a href="https://cplusplus.github.io/CWG/issues/1997.html">1997</a></td> + <td>[<a href="https://wg21.link/basic.indet">basic.indet</a>]</td> <td>CD7</td> <td>Placement new and previous initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1998"> <td><a href="https://cplusplus.github.io/CWG/issues/1998.html">1998</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>NAD</td> <td>Additional sources of xvalue expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="1999"> <td><a href="https://cplusplus.github.io/CWG/issues/1999.html">1999</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>CD4</td> <td>Representation of source characters as universal-character-names</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2000"> <td><a href="https://cplusplus.github.io/CWG/issues/2000.html">2000</a></td> + <td>[<a href="https://wg21.link/lex.pptoken">lex.pptoken</a>]</td> <td>CD4</td> <td><I>header-name</I> outside <TT>#include</TT> directive</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2001"> <td><a href="https://cplusplus.github.io/CWG/issues/2001.html">2001</a></td> + <td>[<a href="https://wg21.link/cpp.pre">cpp.pre</a>]</td> <td>CD4</td> <td><I>non-directive</I> is underspecified</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2002"> <td><a href="https://cplusplus.github.io/CWG/issues/2002.html">2002</a></td> + <td>[<a href="https://wg21.link/cpp.pre">cpp.pre</a>]</td> <td>open</td> <td>White space within preprocessing directives</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2003"> <td><a href="https://cplusplus.github.io/CWG/issues/2003.html">2003</a></td> + <td>[<a href="https://wg21.link/cpp.replace">cpp.replace</a>]</td> <td>drafting</td> <td>Zero-argument macros incorrectly specified</td> <td align="center">Not resolved</td> </tr> <tr id="2004"> <td><a href="https://cplusplus.github.io/CWG/issues/2004.html">2004</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD4</td> <td>Unions with mutable members in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2005"> <td><a href="https://cplusplus.github.io/CWG/issues/2005.html">2005</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td>Incorrect <TT>constexpr</TT> reference initialization requirements</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2006"> <td><a href="https://cplusplus.github.io/CWG/issues/2006.html">2006</a></td> + <td>[<a href="https://wg21.link/basic.compound">basic.compound</a>]</td> <td>CD4</td> <td>Cv-qualified <TT>void</TT> types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2007"> <td><a href="https://cplusplus.github.io/CWG/issues/2007.html">2007</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>CD6</td> <td>Argument-dependent lookup for <TT>operator=</TT></td> <td class="full" align="center">Clang 3.4</td> </tr> <tr id="2008"> <td><a href="https://cplusplus.github.io/CWG/issues/2008.html">2008</a></td> + <td>[<a href="https://wg21.link/temp.arg">temp.arg</a>]</td> <td>CD4</td> <td>Default <I>template-argument</I>s underspecified</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2009"> <td><a href="https://cplusplus.github.io/CWG/issues/2009.html">2009</a></td> + <td>[<a href="https://wg21.link/basic.scope.class">basic.scope.class</a>]</td> <td>CD6</td> <td>Unclear specification of class scope</td> <td class="na" align="center">N/A</td> </tr> <tr id="2010"> <td><a href="https://cplusplus.github.io/CWG/issues/2010.html">2010</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD4</td> <td><I>exception-specification</I>s and conversion operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2011"> <td><a href="https://cplusplus.github.io/CWG/issues/2011.html">2011</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>C++17</td> <td>Unclear effect of reference capture of reference</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2012"> <td><a href="https://cplusplus.github.io/CWG/issues/2012.html">2012</a></td> + <td>[<a href="https://wg21.link/basic.stc">basic.stc</a>]</td> <td>CD4</td> <td>Lifetime of references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2013"> <td><a href="https://cplusplus.github.io/CWG/issues/2013.html">2013</a></td> + <td>[<a href="https://wg21.link/expr.add">expr.add</a>]</td> <td>drafting</td> <td>Pointer subtraction in large array</td> <td align="center">Not resolved</td> </tr> <tr id="2014"> <td><a href="https://cplusplus.github.io/CWG/issues/2014.html">2014</a></td> + <td>[<a href="https://wg21.link/new.delete.array">new.delete.array</a>]</td> <td>NAD</td> <td>Unneeded deallocation signatures</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2015"> <td><a href="https://cplusplus.github.io/CWG/issues/2015.html">2015</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.delete">dcl.fct.def.delete</a>]</td> <td>CD4</td> <td>odr-use of deleted virtual functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2016"> <td><a href="https://cplusplus.github.io/CWG/issues/2016.html">2016</a></td> + <td>[<a href="https://wg21.link/class.conv.fct">class.conv.fct</a>]</td> <td>CD4</td> <td>Confusing wording in description of conversion function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2017"> <td><a href="https://cplusplus.github.io/CWG/issues/2017.html">2017</a></td> + <td>[<a href="https://wg21.link/stmt.return">stmt.return</a>]</td> <td>CD4</td> <td>Flowing off end is not equivalent to no-expression return</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2018"> <td><a href="https://cplusplus.github.io/CWG/issues/2018.html">2018</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>dup</td> <td>Qualification conversion vs reference binding</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2019"> <td><a href="https://cplusplus.github.io/CWG/issues/2019.html">2019</a></td> + <td>[<a href="https://wg21.link/basic.stc.general">basic.stc.general</a>]</td> <td>CD4</td> <td>Member references omitted from description of storage duration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2020"> <td><a href="https://cplusplus.github.io/CWG/issues/2020.html">2020</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD5</td> <td>Inadequate description of odr-use of implicitly-invoked functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2021"> <td><a href="https://cplusplus.github.io/CWG/issues/2021.html">2021</a></td> + <td>[<a href="https://wg21.link/temp.over.link">temp.over.link</a>]</td> <td>dup</td> <td>Function template redeclaration via alias template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2022"> <td><a href="https://cplusplus.github.io/CWG/issues/2022.html">2022</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD4</td> <td>Copy elision in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2023"> <td><a href="https://cplusplus.github.io/CWG/issues/2023.html">2023</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>drafting</td> <td>Composite reference result type of conditional operator</td> <td align="center">Not resolved</td> </tr> <tr id="2024"> <td><a href="https://cplusplus.github.io/CWG/issues/2024.html">2024</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>CD4</td> <td>Dependent types and unexpanded parameter packs</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2025"> <td><a href="https://cplusplus.github.io/CWG/issues/2025.html">2025</a></td> + <td>[<a href="https://wg21.link/temp.over.link">temp.over.link</a>]</td> <td>dup</td> <td>Declaration matching via alias templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2026"> <td><a href="https://cplusplus.github.io/CWG/issues/2026.html">2026</a></td> + <td>[<a href="https://wg21.link/basic.start">basic.start</a>]</td> <td>CD4</td> <td>Zero-initialization and <TT>constexpr</TT></td> <td class="full" align="center">Clang 11</td> </tr> <tr id="2027"> <td><a href="https://cplusplus.github.io/CWG/issues/2027.html">2027</a></td> + <td>[<a href="https://wg21.link/dcl.align">dcl.align</a>]</td> <td>CD4</td> <td>Unclear requirements for multiple <TT>alignas</TT> specifiers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2028"> <td><a href="https://cplusplus.github.io/CWG/issues/2028.html">2028</a></td> + <td>[<a href="https://wg21.link/over.match.ref">over.match.ref</a>]</td> <td>drafting</td> <td>Converting constructors in rvalue reference initialization</td> <td align="center">Not resolved</td> </tr> <tr id="2029"> <td><a href="https://cplusplus.github.io/CWG/issues/2029.html">2029</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>dup</td> <td>Abstract class return type in <TT>decltype</TT> operand</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2030"> <td><a href="https://cplusplus.github.io/CWG/issues/2030.html">2030</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>NAD</td> <td>Access of injected-class-name with template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2031"> <td><a href="https://cplusplus.github.io/CWG/issues/2031.html">2031</a></td> + <td>[<a href="https://wg21.link/diff.cpp03.expr">diff.cpp03.expr</a>]</td> <td>CD4</td> <td>Missing incompatibility for <TT>&&</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2032"> <td><a href="https://cplusplus.github.io/CWG/issues/2032.html">2032</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>CD4</td> <td>Default <I>template-argument</I>s of variable templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2033"> <td><a href="https://cplusplus.github.io/CWG/issues/2033.html">2033</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial.general">temp.spec.partial.general</a>]</td> <td>CD4</td> <td>Redundant restriction on partial specialization argument</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2034"> <td><a href="https://cplusplus.github.io/CWG/issues/2034.html">2034</a></td> + <td>[<a href="https://wg21.link/except.uncaught">except.uncaught</a>]</td> <td>NAD</td> <td>Deprecating <TT>uncaught_exception()</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2035"> <td><a href="https://cplusplus.github.io/CWG/issues/2035.html">2035</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial.match">temp.spec.partial.match</a>]</td> <td>CD3</td> <td>Multi-section example is confusing</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2036"> <td><a href="https://cplusplus.github.io/CWG/issues/2036.html">2036</a></td> + <td>[<a href="https://wg21.link/dcl.decl">dcl.decl</a>]</td> <td>NAD</td> <td>Refactoring <I>parameters-and-qualifiers</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2037"> <td><a href="https://cplusplus.github.io/CWG/issues/2037.html">2037</a></td> + <td>[<a href="https://wg21.link/temp.type">temp.type</a>]</td> <td>drafting</td> <td>Alias templates and template declaration matching</td> <td align="center">Not resolved</td> </tr> <tr id="2038"> <td><a href="https://cplusplus.github.io/CWG/issues/2038.html">2038</a></td> + <td>[<a href="https://wg21.link/diff.cpp14">diff.cpp14</a>]</td> <td>CD4</td> <td>Document C++14 incompatibility of new braced deduction rule</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2039"> <td><a href="https://cplusplus.github.io/CWG/issues/2039.html">2039</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD4</td> <td>Constant conversions to <TT>bool</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2040"> <td><a href="https://cplusplus.github.io/CWG/issues/2040.html">2040</a></td> + <td>[<a href="https://wg21.link/dcl.decl">dcl.decl</a>]</td> <td>CD4</td> <td><I>trailing-return-type</I> no longer ambiguous</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2041"> <td><a href="https://cplusplus.github.io/CWG/issues/2041.html">2041</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>CD4</td> <td>Namespace for explicit class template specialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2042"> <td><a href="https://cplusplus.github.io/CWG/issues/2042.html">2042</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.deallocation">basic.stc.dynamic.deallocation</a>]</td> <td>review</td> <td>Exceptions and deallocation functions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2043"> <td><a href="https://cplusplus.github.io/CWG/issues/2043.html">2043</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>drafting</td> <td>Generalized template arguments and array-to-pointer decay</td> <td align="center">Not resolved</td> </tr> <tr id="2044"> <td><a href="https://cplusplus.github.io/CWG/issues/2044.html">2044</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD4</td> <td><TT>decltype(auto)</TT> and <TT>void</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2045"> <td><a href="https://cplusplus.github.io/CWG/issues/2045.html">2045</a></td> + <td>[<a href="https://wg21.link/temp.over.link">temp.over.link</a>]</td> <td>CD5</td> <td>“Identical” template parameter lists</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2046"> <td><a href="https://cplusplus.github.io/CWG/issues/2046.html">2046</a></td> + <td>[<a href="https://wg21.link/intro.multithread">intro.multithread</a>]</td> <td>C++17</td> <td>Incomplete thread specifications</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2047"> <td><a href="https://cplusplus.github.io/CWG/issues/2047.html">2047</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD4</td> <td>Coordinating “throws anything” specifications</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2048"> <td><a href="https://cplusplus.github.io/CWG/issues/2048.html">2048</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>open</td> <td>C-style casts that cast away constness vs <TT>static_cast</TT></td> <td align="center">Not resolved</td> </tr> <tr id="2049"> <td><a href="https://cplusplus.github.io/CWG/issues/2049.html">2049</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>CD7</td> <td>List initializer in non-type template default argument</td> <td class="full" align="center">Clang 18</td> </tr> <tr id="2050"> <td><a href="https://cplusplus.github.io/CWG/issues/2050.html">2050</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>NAD</td> <td>Consolidate specification of linkage</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2051"> <td><a href="https://cplusplus.github.io/CWG/issues/2051.html">2051</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>CD5</td> <td>Simplifying alias rules</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2052"> <td><a href="https://cplusplus.github.io/CWG/issues/2052.html">2052</a></td> + <td>[<a href="https://wg21.link/over.oper">over.oper</a>]</td> <td>CD4</td> <td>Template argument deduction vs overloaded operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2053"> <td><a href="https://cplusplus.github.io/CWG/issues/2053.html">2053</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>C++20</td> <td><TT>auto</TT> in non-generic lambdas</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2054"> <td><a href="https://cplusplus.github.io/CWG/issues/2054.html">2054</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD7</td> <td>Missing description of class SFINAE</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2055"> <td><a href="https://cplusplus.github.io/CWG/issues/2055.html">2055</a></td> + <td>[<a href="https://wg21.link/temp.arg.explicit">temp.arg.explicit</a>]</td> <td>drafting</td> <td>Explicitly-specified non-deduced parameter packs</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2056"> <td><a href="https://cplusplus.github.io/CWG/issues/2056.html">2056</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>open</td> <td>Member function calls in partially-initialized class objects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2057"> <td><a href="https://cplusplus.github.io/CWG/issues/2057.html">2057</a></td> + <td>[<a href="https://wg21.link/temp.arg.template">temp.arg.template</a>]</td> <td>drafting</td> <td>Template template arguments with default arguments</td> <td align="center">Not resolved</td> </tr> <tr id="2058"> <td><a href="https://cplusplus.github.io/CWG/issues/2058.html">2058</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD6</td> <td>More errors from internal-linkage namespaces</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2059"> <td><a href="https://cplusplus.github.io/CWG/issues/2059.html">2059</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD5</td> <td>Linkage and deduced return types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2060"> <td><a href="https://cplusplus.github.io/CWG/issues/2060.html">2060</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>NAD</td> <td>Deduced return type for explicit specialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2061"> <td><a href="https://cplusplus.github.io/CWG/issues/2061.html">2061</a></td> + <td>[<a href="https://wg21.link/namespace.def">namespace.def</a>]</td> <td>CD4</td> <td>Inline namespace after simplifications</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="2062"> <td><a href="https://cplusplus.github.io/CWG/issues/2062.html">2062</a></td> + <td>[<a href="https://wg21.link/temp.class">temp.class</a>]</td> <td>CD6</td> <td>Class template redeclaration requirements</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2063"> <td><a href="https://cplusplus.github.io/CWG/issues/2063.html">2063</a></td> + <td>[<a href="https://wg21.link/basic.scope.declarative">basic.scope.declarative</a>]</td> <td>CD4</td> <td>Type/nontype hiding in class scope</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2064"> <td><a href="https://cplusplus.github.io/CWG/issues/2064.html">2064</a></td> + <td>[<a href="https://wg21.link/temp.type">temp.type</a>]</td> <td>CD4</td> <td>Conflicting specifications for dependent <I>decltype-specifier</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2065"> <td><a href="https://cplusplus.github.io/CWG/issues/2065.html">2065</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>CD6</td> <td>Current instantiation of a partial specialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2066"> <td><a href="https://cplusplus.github.io/CWG/issues/2066.html">2066</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>CD4</td> <td>Does type-dependent imply value-dependent?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2067"> <td><a href="https://cplusplus.github.io/CWG/issues/2067.html">2067</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>open</td> <td>Generated variadic templates requiring empty pack</td> <td align="center">Not resolved</td> </tr> <tr id="2068"> <td><a href="https://cplusplus.github.io/CWG/issues/2068.html">2068</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD4</td> <td>When can/must a defaulted virtual destructor be defined?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2069"> <td><a href="https://cplusplus.github.io/CWG/issues/2069.html">2069</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD4</td> <td>Do destructors have names?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2070"> <td><a href="https://cplusplus.github.io/CWG/issues/2070.html">2070</a></td> + <td>[<a href="https://wg21.link/class.qual">class.qual</a>]</td> <td>CD6</td> <td><I>using-declaration</I> with dependent <I>nested-name-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2071"> <td><a href="https://cplusplus.github.io/CWG/issues/2071.html">2071</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>CD4</td> <td><TT>typedef</TT> with no declarator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2072"> <td><a href="https://cplusplus.github.io/CWG/issues/2072.html">2072</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>C++23</td> <td>Default argument instantiation for member functions of templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2073"> <td><a href="https://cplusplus.github.io/CWG/issues/2073.html">2073</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.allocation">basic.stc.dynamic.allocation</a>]</td> <td>open</td> <td>Allocating memory for exception objects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2074"> <td><a href="https://cplusplus.github.io/CWG/issues/2074.html">2074</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>drafting</td> <td>Type-dependence of local class of function template</td> <td align="center">Not resolved</td> </tr> <tr id="2075"> <td><a href="https://cplusplus.github.io/CWG/issues/2075.html">2075</a></td> + <td>[<a href="https://wg21.link/over.ics.list">over.ics.list</a>]</td> <td>CD4</td> <td>Passing short initializer lists to array reference parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2076"> <td><a href="https://cplusplus.github.io/CWG/issues/2076.html">2076</a></td> + <td>[<a href="https://wg21.link/over.best.ics">over.best.ics</a>]</td> <td>CD4</td> <td>List-initialization of arguments for constructor parameters</td> <td class="full" align="center">Clang 13</td> </tr> <tr class="open" id="2077"> <td><a href="https://cplusplus.github.io/CWG/issues/2077.html">2077</a></td> + <td>[<a href="https://wg21.link/over.ics.ref">over.ics.ref</a>]</td> <td>drafting</td> <td>Overload resolution and invalid rvalue-reference initialization</td> <td align="center">Not resolved</td> </tr> <tr id="2078"> <td><a href="https://cplusplus.github.io/CWG/issues/2078.html">2078</a></td> + <td>[<a href="https://wg21.link/class.member.lookup">class.member.lookup</a>]</td> <td>NAD</td> <td>Name lookup of <I>mem-initilizer-id</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2079"> <td><a href="https://cplusplus.github.io/CWG/issues/2079.html">2079</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>CD4</td> <td><TT>[[</TT> appearing in a <I>balanced-token-seq</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2080"> <td><a href="https://cplusplus.github.io/CWG/issues/2080.html">2080</a></td> + <td>[<a href="https://wg21.link/class.union">class.union</a>]</td> <td>CD5</td> <td>Example with empty anonymous union member</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2081"> <td><a href="https://cplusplus.github.io/CWG/issues/2081.html">2081</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD5</td> <td>Deduced return type in redeclaration or specialization of function template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2082"> <td><a href="https://cplusplus.github.io/CWG/issues/2082.html">2082</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>CD4</td> <td>Referring to parameters in unevaluated operands of default arguments</td> <td class="full" align="center">Clang 11</td> </tr> <tr id="2083"> <td><a href="https://cplusplus.github.io/CWG/issues/2083.html">2083</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD5</td> <td>Incorrect cases of odr-use</td> <td class="partial" align="center">Partial</td> </tr> <tr id="2084"> <td><a href="https://cplusplus.github.io/CWG/issues/2084.html">2084</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>CD4</td> <td>NSDMIs and deleted union default constructors</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="2085"> <td><a href="https://cplusplus.github.io/CWG/issues/2085.html">2085</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD4</td> <td>Invalid example of adding special member function via default argument</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2086"> <td><a href="https://cplusplus.github.io/CWG/issues/2086.html">2086</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>drafting</td> <td>Reference odr-use vs implicit capture</td> <td align="center">Not resolved</td> </tr> <tr id="2087"> <td><a href="https://cplusplus.github.io/CWG/issues/2087.html">2087</a></td> + <td>[<a href="https://wg21.link/expr.shift">expr.shift</a>]</td> <td>NAD</td> <td>Left shift of negative value by zero bits</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2088"> <td><a href="https://cplusplus.github.io/CWG/issues/2088.html">2088</a></td> + <td>[<a href="https://wg21.link/temp.deduct.partial">temp.deduct.partial</a>]</td> <td>CD5</td> <td>Late tiebreakers in partial ordering</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2089"> <td><a href="https://cplusplus.github.io/CWG/issues/2089.html">2089</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>drafting</td> <td>Restricting selection of builtin overloaded operators</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2090"> <td><a href="https://cplusplus.github.io/CWG/issues/2090.html">2090</a></td> + <td>[<a href="https://wg21.link/temp.dep.temp">temp.dep.temp</a>]</td> <td>open</td> <td>Dependency via non-dependent base class</td> <td align="center">Not resolved</td> </tr> <tr id="2091"> <td><a href="https://cplusplus.github.io/CWG/issues/2091.html">2091</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>CD4</td> <td>Deducing reference non-type template arguments</td> <td class="full" align="center">Clang 10</td> </tr> <tr id="2092"> <td><a href="https://cplusplus.github.io/CWG/issues/2092.html">2092</a></td> + <td>[<a href="https://wg21.link/temp.over">temp.over</a>]</td> <td>CD5</td> <td>Deduction failure and overload resolution</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2093"> <td><a href="https://cplusplus.github.io/CWG/issues/2093.html">2093</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>CD4</td> <td>Qualification conversion for pointer-to-member handler matching</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2094"> <td><a href="https://cplusplus.github.io/CWG/issues/2094.html">2094</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++17</td> <td>Trivial copy/move constructor for class with volatile member</td> <td class="full" align="center">Clang 5</td> </tr> <tr id="2095"> <td><a href="https://cplusplus.github.io/CWG/issues/2095.html">2095</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD4</td> <td>Capturing rvalue references to functions by copy</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2096"> <td><a href="https://cplusplus.github.io/CWG/issues/2096.html">2096</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>CD4</td> <td>Constraints on literal unions</td> <td class="full" align="center">Duplicate of <a href="#2598">2598</a></td> </tr> <tr class="open" id="2097"> <td><a href="https://cplusplus.github.io/CWG/issues/2097.html">2097</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda">expr.prim.lambda</a>]</td> <td>extension</td> <td>Lambdas and <TT>noreturn</TT> attribute</td> <td align="center">Extension</td> </tr> <tr id="2098"> <td><a href="https://cplusplus.github.io/CWG/issues/2098.html">2098</a></td> + <td>[<a href="https://wg21.link/except.uncaught">except.uncaught</a>]</td> <td>CD4</td> <td>Is <TT>uncaught_exceptions()</TT> per-thread?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2099"> <td><a href="https://cplusplus.github.io/CWG/issues/2099.html">2099</a></td> + <td>[<a href="https://wg21.link/dcl.array">dcl.array</a>]</td> <td>CD4</td> <td>Inferring the bound of an array static data member</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2100"> <td><a href="https://cplusplus.github.io/CWG/issues/2100.html">2100</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>C++17</td> <td>Value-dependent address of static data member of class template</td> <td class="full" align="center">Clang 12</td> </tr> <tr id="2101"> <td><a href="https://cplusplus.github.io/CWG/issues/2101.html">2101</a></td> + <td>[<a href="https://wg21.link/temp.dep">temp.dep</a>]</td> <td>CD4</td> <td>Incorrect description of type- and value-dependence</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2102"> <td><a href="https://cplusplus.github.io/CWG/issues/2102.html">2102</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD7</td> <td>Constructor checking in <I>new-expression</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2103"> <td><a href="https://cplusplus.github.io/CWG/issues/2103.html">2103</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD5</td> <td>Lvalue-to-rvalue conversion is irrelevant in odr-use of a reference</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="2104"> <td><a href="https://cplusplus.github.io/CWG/issues/2104.html">2104</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD4</td> <td>Internal-linkage <TT>constexpr</TT> references and ODR requirements</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2105"> <td><a href="https://cplusplus.github.io/CWG/issues/2105.html">2105</a></td> + <td>[<a href="https://wg21.link/temp.arg">temp.arg</a>]</td> <td>open</td> <td>When do the arguments for a parameter pack end?</td> <td align="center">Not resolved</td> </tr> <tr id="2106"> <td><a href="https://cplusplus.github.io/CWG/issues/2106.html">2106</a></td> + <td>[<a href="https://wg21.link/temp.arg.type">temp.arg.type</a>]</td> <td>CD4</td> <td>Unclear restrictions on use of function-type template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2107"> <td><a href="https://cplusplus.github.io/CWG/issues/2107.html">2107</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD4</td> <td>Lifetime of temporaries for default arguments in array copying</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2108"> <td><a href="https://cplusplus.github.io/CWG/issues/2108.html">2108</a></td> + <td>[<a href="https://wg21.link/over.match.ref">over.match.ref</a>]</td> <td>drafting</td> <td>Conversions to non-class prvalues in reference initialization</td> <td align="center">Not resolved</td> </tr> <tr id="2109"> <td><a href="https://cplusplus.github.io/CWG/issues/2109.html">2109</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>CD4</td> <td>Value dependence underspecified</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2110"> <td><a href="https://cplusplus.github.io/CWG/issues/2110.html">2110</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>drafting</td> <td>Overload resolution for base class conversion and reference/non-reference</td> <td align="center">Not resolved</td> </tr> <tr id="2111"> <td><a href="https://cplusplus.github.io/CWG/issues/2111.html">2111</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>NAD</td> <td>Array temporaries in reference binding</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2112"> <td><a href="https://cplusplus.github.io/CWG/issues/2112.html">2112</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD5</td> <td><TT>new auto{x}</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2113"> <td><a href="https://cplusplus.github.io/CWG/issues/2113.html">2113</a></td> + <td>[<a href="https://wg21.link/dcl.meaning">dcl.meaning</a>]</td> <td>CD4</td> <td>Incompete specification of types for declarators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2114"> <td><a href="https://cplusplus.github.io/CWG/issues/2114.html">2114</a></td> + <td>[<a href="https://wg21.link/diff.cpp11.dcl.decl">diff.cpp11.dcl.decl</a>]</td> <td>CD3</td> <td>Missing description of incompatibility from aggregate NSDMIs</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2115"> <td><a href="https://cplusplus.github.io/CWG/issues/2115.html">2115</a></td> + <td>[<a href="https://wg21.link/stmt.jump">stmt.jump</a>]</td> <td>open</td> <td>Order of implicit destruction vs release of automatic storage</td> <td align="center">Not resolved</td> </tr> <tr id="2116"> <td><a href="https://cplusplus.github.io/CWG/issues/2116.html">2116</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>C++17</td> <td>Direct or copy initialization for omitted aggregate initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2117"> <td><a href="https://cplusplus.github.io/CWG/issues/2117.html">2117</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>NAD</td> <td>Explicit specializations and <TT>constexpr</TT> function templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2118"> <td><a href="https://cplusplus.github.io/CWG/issues/2118.html">2118</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>open</td> <td>Stateful metaprogramming via friend injection</td> <td align="center">Not resolved</td> </tr> <tr id="2119"> <td><a href="https://cplusplus.github.io/CWG/issues/2119.html">2119</a></td> + <td>[<a href="https://wg21.link/class.virtual">class.virtual</a>]</td> <td>NAD</td> <td>Disambiguation of multi-level covariant return type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2120"> <td><a href="https://cplusplus.github.io/CWG/issues/2120.html">2120</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD4</td> <td>Array as first non-static data member in standard-layout class</td> <td class="full" align="center">Clang 7</td> </tr> <tr id="2121"> <td><a href="https://cplusplus.github.io/CWG/issues/2121.html">2121</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.general">expr.prim.lambda.general</a>]</td> <td>CD6</td> <td>More flexible lambda syntax</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2122"> <td><a href="https://cplusplus.github.io/CWG/issues/2122.html">2122</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>CD4</td> <td>Glvalues of <TT>void</TT> type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2123"> <td><a href="https://cplusplus.github.io/CWG/issues/2123.html">2123</a></td> + <td>[<a href="https://wg21.link/stmt.dcl">stmt.dcl</a>]</td> <td>open</td> <td>Omitted constant initialization of local static variables</td> <td align="center">Not resolved</td> </tr> <tr id="2124"> <td><a href="https://cplusplus.github.io/CWG/issues/2124.html">2124</a></td> + <td>[<a href="https://wg21.link/defns.signature.member.templ">defns.signature.member.templ</a>]</td> <td>CD4</td> <td>Signature of constructor template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2125"> <td><a href="https://cplusplus.github.io/CWG/issues/2125.html">2125</a></td> + <td>[<a href="https://wg21.link/class.copy.elision">class.copy.elision</a>]</td> <td>NAD</td> <td>Copy elision and comma operator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2126"> <td><a href="https://cplusplus.github.io/CWG/issues/2126.html">2126</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++20</td> <td>Lifetime-extended temporaries in constant expressions</td> <td class="full" align="center">Clang 12</td> </tr> <tr class="open" id="2127"> <td><a href="https://cplusplus.github.io/CWG/issues/2127.html">2127</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial">temp.spec.partial</a>]</td> <td>drafting</td> <td>Partial specialization and nullptr</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2128"> <td><a href="https://cplusplus.github.io/CWG/issues/2128.html">2128</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>open</td> <td>Imprecise rule for reference member initializer</td> <td align="center">Not resolved</td> </tr> <tr id="2129"> <td><a href="https://cplusplus.github.io/CWG/issues/2129.html">2129</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD4</td> <td>Non-object prvalues and constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2130"> <td><a href="https://cplusplus.github.io/CWG/issues/2130.html">2130</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD4</td> <td>Over-aligned types in <I>new-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2131"> <td><a href="https://cplusplus.github.io/CWG/issues/2131.html">2131</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>drafting</td> <td>Ambiguity with <I>opaque-enum-declaration</I></td> <td align="center">Not resolved</td> </tr> <tr id="2132"> <td><a href="https://cplusplus.github.io/CWG/issues/2132.html">2132</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>NAD</td> <td>Deprecated default generated copy constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2133"> <td><a href="https://cplusplus.github.io/CWG/issues/2133.html">2133</a></td> + <td>[<a href="https://wg21.link/conv.fctptr">conv.fctptr</a>]</td> <td>CD5</td> <td>Converting <TT>std::nullptr_t</TT> to <TT>bool</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2134"> <td><a href="https://cplusplus.github.io/CWG/issues/2134.html">2134</a></td> + <td>[<a href="https://wg21.link/expr.prim.general">expr.prim.general</a>]</td> <td>NAD</td> <td>Objectless references to non-static member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2135"> <td><a href="https://cplusplus.github.io/CWG/issues/2135.html">2135</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>NAD</td> <td><I>mem-initializer</I>s for virtual bases of abstract classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2136"> <td><a href="https://cplusplus.github.io/CWG/issues/2136.html">2136</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>NAD</td> <td>Argument-dependent lookup and initializer lists</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2137"> <td><a href="https://cplusplus.github.io/CWG/issues/2137.html">2137</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD4</td> <td>List-initialization from object of same type</td> <td class="full" align="center">Clang 20</td> </tr> <tr id="2138"> <td><a href="https://cplusplus.github.io/CWG/issues/2138.html">2138</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>NAD</td> <td>Explicit member specialization vs implicit instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2139"> <td><a href="https://cplusplus.github.io/CWG/issues/2139.html">2139</a></td> + <td>[<a href="https://wg21.link/conv.fpint">conv.fpint</a>]</td> <td>NAD</td> <td>Floating-point requirements for integer representation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2140"> <td><a href="https://cplusplus.github.io/CWG/issues/2140.html">2140</a></td> + <td>[<a href="https://wg21.link/conv.lval">conv.lval</a>]</td> <td>CD4</td> <td>Lvalue-to-rvalue conversion of <TT>std::nullptr_t</TT></td> <td class="full" align="center">Clang 9</td> </tr> <tr id="2141"> <td><a href="https://cplusplus.github.io/CWG/issues/2141.html">2141</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD4</td> <td>Ambiguity in <I>new-expression</I> with <I>elaborated-type-specifier</I></td> <td class="full" align="center">Clang 17</td> </tr> <tr id="2142"> <td><a href="https://cplusplus.github.io/CWG/issues/2142.html">2142</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>NAD</td> <td>Missing definition of associated classes and namespaces</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2143"> <td><a href="https://cplusplus.github.io/CWG/issues/2143.html">2143</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>C++17</td> <td>Value-dependency via injected-class-name</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2144"> <td><a href="https://cplusplus.github.io/CWG/issues/2144.html">2144</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.general">dcl.fct.def.general</a>]</td> <td>CD7</td> <td>Function/variable declaration ambiguity</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2145"> <td><a href="https://cplusplus.github.io/CWG/issues/2145.html">2145</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.general">dcl.fct.def.general</a>]</td> <td>CD4</td> <td>Parenthesized declarator in function definition</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2146"> <td><a href="https://cplusplus.github.io/CWG/issues/2146.html">2146</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>CD4</td> <td>Scalar object vs memory location in definition of “unsequenced”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2147"> <td><a href="https://cplusplus.github.io/CWG/issues/2147.html">2147</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>CD4</td> <td>Initializer-list arguments and pack deduction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2148"> <td><a href="https://cplusplus.github.io/CWG/issues/2148.html">2148</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>drafting</td> <td>Thread storage duration and order of initialization</td> <td align="center">Not resolved</td> </tr> <tr id="2149"> <td><a href="https://cplusplus.github.io/CWG/issues/2149.html">2149</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>CD7</td> <td>Brace elision and array length deduction</td> <td class="full" align="center">Clang 3.1</td> </tr> <tr id="2150"> <td><a href="https://cplusplus.github.io/CWG/issues/2150.html">2150</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD3</td> <td>Initializer list array lifetime</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2151"> <td><a href="https://cplusplus.github.io/CWG/issues/2151.html">2151</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>CD4</td> <td>Exception object is not created</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2152"> <td><a href="https://cplusplus.github.io/CWG/issues/2152.html">2152</a></td> + <td>[<a href="https://wg21.link/lex.ext">lex.ext</a>]</td> <td>NAD</td> <td>Can an alternative token be used as a <I>ud-suffix</I>?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2153"> <td><a href="https://cplusplus.github.io/CWG/issues/2153.html">2153</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD4</td> <td><I>pure-specifier</I> in friend declaration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2154"> <td><a href="https://cplusplus.github.io/CWG/issues/2154.html">2154</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD4</td> <td>Ambiguity of <I>pure-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2155"> <td><a href="https://cplusplus.github.io/CWG/issues/2155.html">2155</a></td> + <td>[<a href="https://wg21.link/namespace.memdef">namespace.memdef</a>]</td> <td>C++17</td> <td>Defining classes and enumerations via <I>using-declaration</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2156"> <td><a href="https://cplusplus.github.io/CWG/issues/2156.html">2156</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>CD4</td> <td>Definition of enumeration declared by <I>using-declaration</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2157"> <td><a href="https://cplusplus.github.io/CWG/issues/2157.html">2157</a></td> + <td>[<a href="https://wg21.link/dcl.type.elab">dcl.type.elab</a>]</td> <td>CD4</td> <td>Further disambiguation of enumeration <I>elaborated-type-specifier</I></td> <td class="full" align="center">Clang 11</td> </tr> <tr class="open" id="2158"> <td><a href="https://cplusplus.github.io/CWG/issues/2158.html">2158</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>drafting</td> <td>Polymorphic behavior during destruction</td> <td align="center">Not resolved</td> </tr> <tr id="2159"> <td><a href="https://cplusplus.github.io/CWG/issues/2159.html">2159</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>NAD</td> <td>Lambda capture and local <TT>thread_local</TT> variables</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2160"> <td><a href="https://cplusplus.github.io/CWG/issues/2160.html">2160</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>open</td> <td>Issues with partial ordering</td> <td align="center">Not resolved</td> </tr> <tr id="2161"> <td><a href="https://cplusplus.github.io/CWG/issues/2161.html">2161</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>NAD</td> <td>Explicit instantiation declaration and “preceding initialization”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2162"> <td><a href="https://cplusplus.github.io/CWG/issues/2162.html">2162</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD3</td> <td>Capturing <TT>this</TT> by reference</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2163"> <td><a href="https://cplusplus.github.io/CWG/issues/2163.html">2163</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD4</td> <td>Labels in <TT>constexpr</TT> functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2164"> <td><a href="https://cplusplus.github.io/CWG/issues/2164.html">2164</a></td> + <td>[<a href="https://wg21.link/basic.scope.hiding">basic.scope.hiding</a>]</td> <td>CD5</td> <td>Name hiding and <I>using-directive</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2165"> <td><a href="https://cplusplus.github.io/CWG/issues/2165.html">2165</a></td> + <td>[<a href="https://wg21.link/basic.scope.declarative">basic.scope.declarative</a>]</td> <td>CD6</td> <td>Namespaces, declarative regions, and translation units</td> <td class="na" align="center">N/A</td> </tr> <tr class="open" id="2166"> <td><a href="https://cplusplus.github.io/CWG/issues/2166.html">2166</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>drafting</td> <td>Unclear meaning of “undefined <TT>constexpr</TT> function”</td> <td align="center">Not resolved</td> </tr> <tr id="2167"> <td><a href="https://cplusplus.github.io/CWG/issues/2167.html">2167</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD4</td> <td>Non-member references with lifetimes within the current evaluation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2168"> <td><a href="https://cplusplus.github.io/CWG/issues/2168.html">2168</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>review</td> <td>Narrowing conversions and +/- infinity</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2169"> <td><a href="https://cplusplus.github.io/CWG/issues/2169.html">2169</a></td> + <td>[<a href="https://wg21.link/over.ics.list">over.ics.list</a>]</td> <td>open</td> <td>Narrowing conversions and overload resolution</td> <td align="center">Not resolved</td> </tr> <tr id="2170"> <td><a href="https://cplusplus.github.io/CWG/issues/2170.html">2170</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD5</td> <td>Unclear definition of odr-use for arrays</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="2171"> <td><a href="https://cplusplus.github.io/CWG/issues/2171.html">2171</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD4</td> <td>Triviality of copy constructor with less-qualified parameter</td> <td class="full" align="center">Clang 15</td> </tr> <tr class="open" id="2172"> <td><a href="https://cplusplus.github.io/CWG/issues/2172.html">2172</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>drafting</td> <td>Multiple exceptions with one exception object</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2173"> <td><a href="https://cplusplus.github.io/CWG/issues/2173.html">2173</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial">temp.spec.partial</a>]</td> <td>open</td> <td>Partial specialization with non-deduced contexts</td> <td align="center">Not resolved</td> </tr> <tr id="2174"> <td><a href="https://cplusplus.github.io/CWG/issues/2174.html">2174</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>C++17</td> <td>Unclear rules for friend definitions in templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2175"> <td><a href="https://cplusplus.github.io/CWG/issues/2175.html">2175</a></td> + <td>[<a href="https://wg21.link/dcl.ambig.res">dcl.ambig.res</a>]</td> <td>CD4</td> <td>Ambiguity with attribute in conversion operator declaration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2176"> <td><a href="https://cplusplus.github.io/CWG/issues/2176.html">2176</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD4</td> <td>Destroying the returned object when a destructor throws</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2177"> <td><a href="https://cplusplus.github.io/CWG/issues/2177.html">2177</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD5</td> <td>Placement <TT>operator delete</TT> and parameter copies</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2178"> <td><a href="https://cplusplus.github.io/CWG/issues/2178.html">2178</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>NAD</td> <td>Substitution of dependent template arguments in default template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2179"> <td><a href="https://cplusplus.github.io/CWG/issues/2179.html">2179</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial.general">temp.spec.partial.general</a>]</td> <td>drafting</td> <td>Required diagnostic for partial specialization after first use</td> <td align="center">Not resolved</td> </tr> <tr id="2180"> <td><a href="https://cplusplus.github.io/CWG/issues/2180.html">2180</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>CD4</td> <td>Virtual bases in destructors and defaulted assignment operators</td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="2181"> <td><a href="https://cplusplus.github.io/CWG/issues/2181.html">2181</a></td> + <td>[<a href="https://wg21.link/implimits">implimits</a>]</td> <td>C++20</td> <td>Normative requirements in an informative Annex</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2182"> <td><a href="https://cplusplus.github.io/CWG/issues/2182.html">2182</a></td> + <td>[<a href="https://wg21.link/expr.add">expr.add</a>]</td> <td>drafting</td> <td>Pointer arithmetic in array-like containers</td> <td align="center">Not resolved</td> </tr> <tr id="2183"> <td><a href="https://cplusplus.github.io/CWG/issues/2183.html">2183</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>NAD</td> <td>Problems in description of potential exceptions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2184"> <td><a href="https://cplusplus.github.io/CWG/issues/2184.html">2184</a></td> + <td>[<a href="https://wg21.link/diff.expr">diff.expr</a>]</td> <td>CD4</td> <td>Missing C compatibility entry for decrement of <TT>bool</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2185"> <td><a href="https://cplusplus.github.io/CWG/issues/2185.html">2185</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>CD6</td> <td>Cv-qualified numeric types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2186"> <td><a href="https://cplusplus.github.io/CWG/issues/2186.html">2186</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++20</td> <td>Unclear point that “preceding initialization” must precede</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2187"> <td><a href="https://cplusplus.github.io/CWG/issues/2187.html">2187</a></td> + <td>[<a href="https://wg21.link/class.protected">class.protected</a>]</td> <td>drafting</td> <td>Protected members and access via <I>qualified-id</I></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2188"> <td><a href="https://cplusplus.github.io/CWG/issues/2188.html">2188</a></td> + <td>[<a href="https://wg21.link/class.mem.general">class.mem.general</a>]</td> <td>open</td> <td><I>empty-declaration</I> grammar ambiguity</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2189"> <td><a href="https://cplusplus.github.io/CWG/issues/2189.html">2189</a></td> + <td>[<a href="https://wg21.link/over.call.object">over.call.object</a>]</td> <td>open</td> <td>Surrogate call template</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2190"> <td><a href="https://cplusplus.github.io/CWG/issues/2190.html">2190</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>open</td> <td>Insufficient specification of <TT>__has_include</TT></td> <td align="center">Not resolved</td> </tr> <tr id="2191"> <td><a href="https://cplusplus.github.io/CWG/issues/2191.html">2191</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>C++17</td> <td>Incorrect result for <TT>noexcept(typeid(v))</TT></td> <td class="full" align="center">Clang 19</td> </tr> <tr class="open" id="2192"> <td><a href="https://cplusplus.github.io/CWG/issues/2192.html">2192</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Constant expressions and order-of-eval undefined behavior</td> <td align="center">Not resolved</td> </tr> <tr id="2193"> <td><a href="https://cplusplus.github.io/CWG/issues/2193.html">2193</a></td> + <td>[<a href="https://wg21.link/numeric.limits.members">numeric.limits.members</a>]</td> <td>NAD</td> <td><TT>numeric_limits<int>::radix</TT> and <TT>digits</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2194"> <td><a href="https://cplusplus.github.io/CWG/issues/2194.html">2194</a></td> + <td>[<a href="https://wg21.link/over.match.list">over.match.list</a>]</td> <td>drafting</td> <td>Impossible case in list initialization</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2195"> <td><a href="https://cplusplus.github.io/CWG/issues/2195.html">2195</a></td> + <td>[<a href="https://wg21.link/dcl.type.cv">dcl.type.cv</a>]</td> <td>open</td> <td>Unsolicited reading of trailing volatile members</td> <td align="center">Not resolved</td> </tr> <tr id="2196"> <td><a href="https://cplusplus.github.io/CWG/issues/2196.html">2196</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>C++17</td> <td>Zero-initialization with virtual base classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2197"> <td><a href="https://cplusplus.github.io/CWG/issues/2197.html">2197</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>C++17</td> <td>Overload resolution and deleted special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2198"> <td><a href="https://cplusplus.github.io/CWG/issues/2198.html">2198</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>C++17</td> <td>Linkage of enumerators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2199"> <td><a href="https://cplusplus.github.io/CWG/issues/2199.html">2199</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>CD6</td> <td>Typedefs and tags</td> <td class="full" align="center">Clang 3.8</td> </tr> <tr id="2200"> <td><a href="https://cplusplus.github.io/CWG/issues/2200.html">2200</a></td> + <td>[<a href="https://wg21.link/temp.arg.explicit">temp.arg.explicit</a>]</td> <td>NAD</td> <td>Conversions in template argument deduction</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2201"> <td><a href="https://cplusplus.github.io/CWG/issues/2201.html">2201</a></td> + <td>[<a href="https://wg21.link/basic.type.qualifier">basic.type.qualifier</a>]</td> <td>C++17</td> <td>Cv-qualification of array types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2202"> <td><a href="https://cplusplus.github.io/CWG/issues/2202.html">2202</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>drafting</td> <td>When does default argument instantiation occur?</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2203"> <td><a href="https://cplusplus.github.io/CWG/issues/2203.html">2203</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>drafting</td> <td>Defaulted copy/move constructors and UDCs</td> <td align="center">Not resolved</td> </tr> <tr id="2204"> <td><a href="https://cplusplus.github.io/CWG/issues/2204.html">2204</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>NAD</td> <td>Naming delegated constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2205"> <td><a href="https://cplusplus.github.io/CWG/issues/2205.html">2205</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>C++17</td> <td>Restrictions on use of <TT>alignas</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2206"> <td><a href="https://cplusplus.github.io/CWG/issues/2206.html">2206</a></td> + <td>[<a href="https://wg21.link/expr">expr</a>]</td> <td>C++17</td> <td>Composite type of object and function pointers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2207"> <td><a href="https://cplusplus.github.io/CWG/issues/2207.html">2207</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.allocation">basic.stc.dynamic.allocation</a>]</td> <td>CD5</td> <td>Alignment of allocation function return value</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2208"> <td><a href="https://cplusplus.github.io/CWG/issues/2208.html">2208</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>NAD</td> <td><I>static_assert-declaration</I> does not declare a member</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2209"> <td><a href="https://cplusplus.github.io/CWG/issues/2209.html">2209</a></td> + <td>[<a href="https://wg21.link/except.ctor">except.ctor</a>]</td> <td>NAD</td> <td>Destruction of constructed array elements</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2210"> <td><a href="https://cplusplus.github.io/CWG/issues/2210.html">2210</a></td> + <td>[<a href="https://wg21.link/except.ctor">except.ctor</a>]</td> <td>NAD</td> <td>Principal/target constructor confusion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2211"> <td><a href="https://cplusplus.github.io/CWG/issues/2211.html">2211</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>C++17</td> <td>Hiding by lambda captures and parameters</td> <td class="full" align="center">Clang 8</td> </tr> <tr id="2212"> <td><a href="https://cplusplus.github.io/CWG/issues/2212.html">2212</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>CD5</td> <td>Typedef changing linkage after use</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2213"> <td><a href="https://cplusplus.github.io/CWG/issues/2213.html">2213</a></td> + <td>[<a href="https://wg21.link/dcl.type.elab">dcl.type.elab</a>]</td> <td>CD6</td> <td>Forward declaration of partial specializations</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="2214"> <td><a href="https://cplusplus.github.io/CWG/issues/2214.html">2214</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>C++17</td> <td>Missing requirement on representation of integer values</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2215"> <td><a href="https://cplusplus.github.io/CWG/issues/2215.html">2215</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>C++17</td> <td>Redundant description of language linkage in function call</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2216"> <td><a href="https://cplusplus.github.io/CWG/issues/2216.html">2216</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>NAD</td> <td>Exception specifications in unevaluated contexts</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2217"> <td><a href="https://cplusplus.github.io/CWG/issues/2217.html">2217</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>NAD</td> <td><TT>constexpr</TT> constructors for non-literal types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2218"> <td><a href="https://cplusplus.github.io/CWG/issues/2218.html">2218</a></td> + <td>[<a href="https://wg21.link/basic.lookup">basic.lookup</a>]</td> <td>C++17</td> <td>Ambiguity and namespace aliases</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2219"> <td><a href="https://cplusplus.github.io/CWG/issues/2219.html">2219</a></td> + <td>[<a href="https://wg21.link/except.handle">except.handle</a>]</td> <td>drafting</td> <td>Dynamically-unreachable handlers</td> <td align="center">Not resolved</td> </tr> <tr id="2220"> <td><a href="https://cplusplus.github.io/CWG/issues/2220.html">2220</a></td> + <td>[<a href="https://wg21.link/stmt.ranged">stmt.ranged</a>]</td> <td>C++17</td> <td>Hiding index variable in range-based <TT>for</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2221"> <td><a href="https://cplusplus.github.io/CWG/issues/2221.html">2221</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD6</td> <td>Copying volatile objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2222"> <td><a href="https://cplusplus.github.io/CWG/issues/2222.html">2222</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>drafting</td> <td>Additional contexts where instantiation is not required</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2223"> <td><a href="https://cplusplus.github.io/CWG/issues/2223.html">2223</a></td> + <td>[<a href="https://wg21.link/dcl.align">dcl.align</a>]</td> <td>drafting</td> <td>Multiple <TT>alignas</TT> specifiers</td> <td align="center">Not resolved</td> </tr> <tr id="2224"> <td><a href="https://cplusplus.github.io/CWG/issues/2224.html">2224</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>C++17</td> <td>Member subobjects and base-class casts</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2225"> <td><a href="https://cplusplus.github.io/CWG/issues/2225.html">2225</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>NAD</td> <td><TT>reinterpret_cast</TT> to same floating-point type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2226"> <td><a href="https://cplusplus.github.io/CWG/issues/2226.html">2226</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD5</td> <td>Xvalues vs lvalues in conditional expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2227"> <td><a href="https://cplusplus.github.io/CWG/issues/2227.html">2227</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>CD5</td> <td>Destructor access and default member initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2228"> <td><a href="https://cplusplus.github.io/CWG/issues/2228.html">2228</a></td> + <td>[<a href="https://wg21.link/dcl.ambig.res">dcl.ambig.res</a>]</td> <td>review</td> <td>Ambiguity resolution for cast to function type</td> <td align="center">Not resolved</td> </tr> <tr id="2229"> <td><a href="https://cplusplus.github.io/CWG/issues/2229.html">2229</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>CD5</td> <td>Volatile unnamed bit-fields</td> <td class="full" align="center">Clang 7</td> </tr> <tr id="2230"> <td><a href="https://cplusplus.github.io/CWG/issues/2230.html">2230</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>NAD</td> <td>Linkage of <TT>extern "C"</TT> function in unnamed namespace</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2231"> <td><a href="https://cplusplus.github.io/CWG/issues/2231.html">2231</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>NAD</td> <td>Class member access to static data member template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2232"> <td><a href="https://cplusplus.github.io/CWG/issues/2232.html">2232</a></td> + <td>[<a href="https://wg21.link/dcl.stc">dcl.stc</a>]</td> <td>open</td> <td><TT>thread_local</TT> anonymous unions</td> <td align="center">Not resolved</td> </tr> <tr id="2233"> <td><a href="https://cplusplus.github.io/CWG/issues/2233.html">2233</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>CD5</td> <td>Function parameter packs following default arguments</td> <td class="full" align="center">Clang 11</td> </tr> <tr id="2234"> <td><a href="https://cplusplus.github.io/CWG/issues/2234.html">2234</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD5</td> <td>Missing rules for <I>simple-template-id</I> as <I>class-name</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2235"> <td><a href="https://cplusplus.github.io/CWG/issues/2235.html">2235</a></td> + <td>[<a href="https://wg21.link/temp.deduct.partial">temp.deduct.partial</a>]</td> <td>CD5</td> <td>Partial ordering and non-dependent types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2236"> <td><a href="https://cplusplus.github.io/CWG/issues/2236.html">2236</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>drafting</td> <td>When is an alias template specialization dependent?</td> <td align="center">Not resolved</td> </tr> <tr id="2237"> <td><a href="https://cplusplus.github.io/CWG/issues/2237.html">2237</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>CD5</td> <td>Can a <I>template-id</I> name a constructor?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2238"> <td><a href="https://cplusplus.github.io/CWG/issues/2238.html">2238</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.allocation">basic.stc.dynamic.allocation</a>]</td> <td>NAD</td> <td>Contradictory alignment requirements for allocation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2239"> <td><a href="https://cplusplus.github.io/CWG/issues/2239.html">2239</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>NAD</td> <td>Sized deallocation with a trivial destructor</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2240"> <td><a href="https://cplusplus.github.io/CWG/issues/2240.html">2240</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>NAD</td> <td><TT>this</TT> is not odr-used in a constant expression</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2241"> <td><a href="https://cplusplus.github.io/CWG/issues/2241.html">2241</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD5</td> <td>Overload resolution is not invoked with a single function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2242"> <td><a href="https://cplusplus.github.io/CWG/issues/2242.html">2242</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>C++23</td> <td>ODR violation with constant initialization possibly omitted</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2243"> <td><a href="https://cplusplus.github.io/CWG/issues/2243.html">2243</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>drafting</td> <td>Incorrect use of implicit conversion sequence</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2244"> <td><a href="https://cplusplus.github.io/CWG/issues/2244.html">2244</a></td> + <td>[<a href="https://wg21.link/class.protected">class.protected</a>]</td> <td>open</td> <td>Base class access in aggregate initialization</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2245"> <td><a href="https://cplusplus.github.io/CWG/issues/2245.html">2245</a></td> + <td>[<a href="https://wg21.link/temp.point">temp.point</a>]</td> <td>drafting</td> <td>Point of instantiation of incomplete class template</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2246"> <td><a href="https://cplusplus.github.io/CWG/issues/2246.html">2246</a></td> + <td>[<a href="https://wg21.link/class.access.base">class.access.base</a>]</td> <td>drafting</td> <td>Access of indirect virtual base class constructors</td> <td align="center">Not resolved</td> </tr> <tr id="2247"> <td><a href="https://cplusplus.github.io/CWG/issues/2247.html">2247</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>C++17</td> <td>Lambda capture and variable argument list</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2248"> <td><a href="https://cplusplus.github.io/CWG/issues/2248.html">2248</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>C++17</td> <td>Problems with sized delete</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2249"> <td><a href="https://cplusplus.github.io/CWG/issues/2249.html">2249</a></td> + <td>[<a href="https://wg21.link/expr.prim.id.unqual">expr.prim.id.unqual</a>]</td> <td>CD5</td> <td><I>identifier</I>s and <I>id-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2250"> <td><a href="https://cplusplus.github.io/CWG/issues/2250.html">2250</a></td> + <td>[<a href="https://wg21.link/temp.point">temp.point</a>]</td> <td>open</td> <td>Implicit instantiation, destruction, and TUs</td> <td align="center">Not resolved</td> </tr> <tr id="2251"> <td><a href="https://cplusplus.github.io/CWG/issues/2251.html">2251</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>C++17</td> <td>Unreachable enumeration list-initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2252"> <td><a href="https://cplusplus.github.io/CWG/issues/2252.html">2252</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD7</td> <td>Enumeration list-initialization from the same type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2253"> <td><a href="https://cplusplus.github.io/CWG/issues/2253.html">2253</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>CD5</td> <td>Unnamed bit-fields and zero-initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2254"> <td><a href="https://cplusplus.github.io/CWG/issues/2254.html">2254</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD5</td> <td>Standard-layout classes and bit-fields</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2255"> <td><a href="https://cplusplus.github.io/CWG/issues/2255.html">2255</a></td> + <td>[<a href="https://wg21.link/temp.spec">temp.spec</a>]</td> <td>CD5</td> <td>Instantiated static data member templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2256"> <td><a href="https://cplusplus.github.io/CWG/issues/2256.html">2256</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD5</td> <td>Lifetime of trivially-destructible objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2257"> <td><a href="https://cplusplus.github.io/CWG/issues/2257.html">2257</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD5</td> <td>Lifetime extension of references vs exceptions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2258"> <td><a href="https://cplusplus.github.io/CWG/issues/2258.html">2258</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>open</td> <td>Storage deallocation during period of destruction</td> <td align="center">Not resolved</td> </tr> <tr id="2259"> <td><a href="https://cplusplus.github.io/CWG/issues/2259.html">2259</a></td> + <td>[<a href="https://wg21.link/dcl.ambig.res">dcl.ambig.res</a>]</td> <td>C++17</td> <td>Unclear context describing ambiguity</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2260"> <td><a href="https://cplusplus.github.io/CWG/issues/2260.html">2260</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>CD5</td> <td>Explicit specializations of deleted member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2261"> <td><a href="https://cplusplus.github.io/CWG/issues/2261.html">2261</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>extension</td> <td>Explicit instantiation of in-class <TT>friend</TT> definition</td> <td align="center">Extension</td> </tr> <tr id="2262"> <td><a href="https://cplusplus.github.io/CWG/issues/2262.html">2262</a></td> + <td>[<a href="https://wg21.link/dcl.asm">dcl.asm</a>]</td> <td>C++17</td> <td>Attributes for <I>asm-definition</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2263"> <td><a href="https://cplusplus.github.io/CWG/issues/2263.html">2263</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>drafting</td> <td>Default argument instantiation for <TT>friend</TT>s</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2264"> <td><a href="https://cplusplus.github.io/CWG/issues/2264.html">2264</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>drafting</td> <td>Memberwise copying with indeterminate value</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2265"> <td><a href="https://cplusplus.github.io/CWG/issues/2265.html">2265</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>drafting</td> <td>Delayed pack expansion and member redeclarations</td> <td align="center">Not resolved</td> </tr> <tr id="2266"> <td><a href="https://cplusplus.github.io/CWG/issues/2266.html">2266</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>CD5</td> <td>Has dependent type vs is type-dependent</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2267"> <td><a href="https://cplusplus.github.io/CWG/issues/2267.html">2267</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD5</td> <td>Copy-initialization of temporary in reference direct-initialization</td> <td class="none" align="center">No</td> </tr> <tr id="2268"> <td><a href="https://cplusplus.github.io/CWG/issues/2268.html">2268</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++17</td> <td>Unions with mutable members in constant expressions revisited</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2269"> <td><a href="https://cplusplus.github.io/CWG/issues/2269.html">2269</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>dup</td> <td>Additional recursive references in aggregate DMIs</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2270"> <td><a href="https://cplusplus.github.io/CWG/issues/2270.html">2270</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>NAD</td> <td>Non-inline functions and explicit instantiation declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2271"> <td><a href="https://cplusplus.github.io/CWG/issues/2271.html">2271</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>C++17</td> <td>Aliasing <TT>this</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2272"> <td><a href="https://cplusplus.github.io/CWG/issues/2272.html">2272</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>C++17</td> <td>Implicit initialization of aggregate members of reference type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2273"> <td><a href="https://cplusplus.github.io/CWG/issues/2273.html">2273</a></td> + <td>[<a href="https://wg21.link/class.ctor">class.ctor</a>]</td> <td>CD5</td> <td>Inheriting constructors vs implicit default constructor</td> <td class="full" align="center">Clang 3.3</td> </tr> <tr id="2274"> <td><a href="https://cplusplus.github.io/CWG/issues/2274.html">2274</a></td> + <td>[<a href="https://wg21.link/stmt.if">stmt.if</a>]</td> <td>NAD</td> <td>Generic lambda capture vs constexpr if</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2275"> <td><a href="https://cplusplus.github.io/CWG/issues/2275.html">2275</a></td> + <td>[<a href="https://wg21.link/temp.dep.expr">temp.dep.expr</a>]</td> <td>drafting</td> <td>Type-dependence of function template</td> <td align="center">Not resolved</td> </tr> <tr id="2276"> <td><a href="https://cplusplus.github.io/CWG/issues/2276.html">2276</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>C++17</td> <td>Dependent <TT>noexcept</TT> and function type-dependence</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2277"> <td><a href="https://cplusplus.github.io/CWG/issues/2277.html">2277</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>CD5</td> <td>Ambiguity inheriting constructors with default arguments</td> <td class="partial" align="center">Partial</td> </tr> <tr id="2278"> <td><a href="https://cplusplus.github.io/CWG/issues/2278.html">2278</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD5</td> <td>Copy elision in constant expressions reconsidered</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2279"> <td><a href="https://cplusplus.github.io/CWG/issues/2279.html">2279</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>NAD</td> <td>Multiple <I>attribute-specifier</I>s in one <I>attribute-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2280"> <td><a href="https://cplusplus.github.io/CWG/issues/2280.html">2280</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>C++20</td> <td>Matching a usual deallocation function with placement new</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2281"> <td><a href="https://cplusplus.github.io/CWG/issues/2281.html">2281</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>drafting</td> <td>Consistency of aligned <TT>operator delete</TT> replacement</td> <td align="center">Not resolved</td> </tr> <tr id="2282"> <td><a href="https://cplusplus.github.io/CWG/issues/2282.html">2282</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>C++20</td> <td>Consistency with mismatched aligned/non-over-aligned allocation/deallocation functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2283"> <td><a href="https://cplusplus.github.io/CWG/issues/2283.html">2283</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD7</td> <td>Missing complete type requirements</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2284"> <td><a href="https://cplusplus.github.io/CWG/issues/2284.html">2284</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>open</td> <td>Sequencing of <I>braced-init-list</I> arguments</td> <td align="center">Not resolved</td> </tr> <tr id="2285"> <td><a href="https://cplusplus.github.io/CWG/issues/2285.html">2285</a></td> + <td>[<a href="https://wg21.link/dcl.struct.bind">dcl.struct.bind</a>]</td> <td>CD5</td> <td>Issues with structured bindings</td> <td class="full" align="center">Clang 4</td> </tr> <tr id="2286"> <td><a href="https://cplusplus.github.io/CWG/issues/2286.html">2286</a></td> + <td>[<a href="https://wg21.link/expr.assign">expr.assign</a>]</td> <td>NAD</td> <td>Assignment evaluation order</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2287"> <td><a href="https://cplusplus.github.io/CWG/issues/2287.html">2287</a></td> + <td>[<a href="https://wg21.link/basic.compound">basic.compound</a>]</td> <td>CD5</td> <td>Pointer-interconvertibility in non-standard-layout unions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2288"> <td><a href="https://cplusplus.github.io/CWG/issues/2288.html">2288</a></td> + <td>[<a href="https://wg21.link/dcl.pre">dcl.pre</a>]</td> <td>NAD</td> <td>Contradictory optionality in <I>simple-declaration</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2289"> <td><a href="https://cplusplus.github.io/CWG/issues/2289.html">2289</a></td> + <td>[<a href="https://wg21.link/basic.scope.declarative">basic.scope.declarative</a>]</td> <td>CD5</td> <td>Uniqueness of structured binding names</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2290"> <td><a href="https://cplusplus.github.io/CWG/issues/2290.html">2290</a></td> + <td>[<a href="https://wg21.link/over.match.funcs">over.match.funcs</a>]</td> <td>CD5</td> <td>Unclear specification for overload resolution and deleted special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2291"> <td><a href="https://cplusplus.github.io/CWG/issues/2291.html">2291</a></td> + <td>[<a href="https://wg21.link/over.best.ics">over.best.ics</a>]</td> <td>dup</td> <td>Implicit conversion sequences in non-call contexts</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2292"> <td><a href="https://cplusplus.github.io/CWG/issues/2292.html">2292</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>CD5</td> <td><I>simple-template-id</I> is ambiguous between <I>class-name</I> and <I>type-name</I></td> <td class="full" align="center">Clang 9</td> </tr> <tr id="2293"> <td><a href="https://cplusplus.github.io/CWG/issues/2293.html">2293</a></td> + <td>[<a href="https://wg21.link/class">class</a>]</td> <td>CD5</td> <td>Requirements for <I>simple-template-id</I> used as a <I>class-name</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2294"> <td><a href="https://cplusplus.github.io/CWG/issues/2294.html">2294</a></td> + <td>[<a href="https://wg21.link/temp.dep.expr">temp.dep.expr</a>]</td> <td>CD5</td> <td>Dependent <TT>auto</TT> static data members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2295"> <td><a href="https://cplusplus.github.io/CWG/issues/2295.html">2295</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>CD5</td> <td>Aggregates with deleted defaulted constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2296"> <td><a href="https://cplusplus.github.io/CWG/issues/2296.html">2296</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>open</td> <td>Are default argument instantiation failures in the “immediate context”?</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2297"> <td><a href="https://cplusplus.github.io/CWG/issues/2297.html">2297</a></td> + <td>[<a href="https://wg21.link/intro.races">intro.races</a>]</td> <td>open</td> <td>Unclear specification of atomic operations</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2298"> <td><a href="https://cplusplus.github.io/CWG/issues/2298.html">2298</a></td> + <td>[<a href="https://wg21.link/intro.races">intro.races</a>]</td> <td>open</td> <td>Actions and expression evaluation</td> <td align="center">Not resolved</td> </tr> <tr id="2299"> <td><a href="https://cplusplus.github.io/CWG/issues/2299.html">2299</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD5</td> <td><TT>constexpr</TT> vararg functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2300"> <td><a href="https://cplusplus.github.io/CWG/issues/2300.html">2300</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD5</td> <td>Lambdas in multiple definitions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2301"> <td><a href="https://cplusplus.github.io/CWG/issues/2301.html">2301</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Value-initialization and constexpr constructor evaluation</td> <td align="center">Not resolved</td> </tr> <tr id="2302"> <td><a href="https://cplusplus.github.io/CWG/issues/2302.html">2302</a></td> + <td>[<a href="https://wg21.link/expr.eq">expr.eq</a>]</td> <td>NAD</td> <td>Address comparison between different member subobjects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2303"> <td><a href="https://cplusplus.github.io/CWG/issues/2303.html">2303</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>CD5</td> <td>Partial ordering and recursive variadic inheritance</td> <td class="full" align="center">Clang 12</td> </tr> <tr id="2304"> <td><a href="https://cplusplus.github.io/CWG/issues/2304.html">2304</a></td> + <td>[<a href="https://wg21.link/over.best.ics">over.best.ics</a>]</td> <td>NAD</td> <td>Incomplete type vs overload resolution</td> <td class="full" align="center">Clang 2.8</td> </tr> <tr id="2305"> <td><a href="https://cplusplus.github.io/CWG/issues/2305.html">2305</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>CD5</td> <td>Explicit instantiation of constexpr or inline variable template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2306"> <td><a href="https://cplusplus.github.io/CWG/issues/2306.html">2306</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>NAD</td> <td>Nested friend templates of class templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2307"> <td><a href="https://cplusplus.github.io/CWG/issues/2307.html">2307</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>CD5</td> <td>Unclear definition of “equivalent to a nontype template parameter”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2308"> <td><a href="https://cplusplus.github.io/CWG/issues/2308.html">2308</a></td> + <td>[<a href="https://wg21.link/dcl.struct.bind">dcl.struct.bind</a>]</td> <td>NAD</td> <td>Structured bindings and lambda capture</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2309"> <td><a href="https://cplusplus.github.io/CWG/issues/2309.html">2309</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD5</td> <td>Restrictions on nested statements within <TT>constexpr</TT> functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2310"> <td><a href="https://cplusplus.github.io/CWG/issues/2310.html">2310</a></td> + <td>[<a href="https://wg21.link/conv.ptr">conv.ptr</a>]</td> <td>CD5</td> <td>Type completeness and derived-to-base pointer conversions</td> <td class="partial" align="center">Partial</td> </tr> <tr class="open" id="2311"> <td><a href="https://cplusplus.github.io/CWG/issues/2311.html">2311</a></td> + <td>[<a href="https://wg21.link/over.match.list">over.match.list</a>]</td> <td>open</td> <td>Missed case for guaranteed copy elision</td> <td align="center">Not resolved</td> </tr> <tr id="2312"> <td><a href="https://cplusplus.github.io/CWG/issues/2312.html">2312</a></td> + <td>[<a href="https://wg21.link/dcl.struct.bind">dcl.struct.bind</a>]</td> <td>CD6</td> <td>Structured bindings and <TT>mutable</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2313"> <td><a href="https://cplusplus.github.io/CWG/issues/2313.html">2313</a></td> + <td>[<a href="https://wg21.link/dcl.struct.bind">dcl.struct.bind</a>]</td> <td>CD5</td> <td>Redeclaration of structured binding reference variables</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2314"> <td><a href="https://cplusplus.github.io/CWG/issues/2314.html">2314</a></td> + <td>[<a href="https://wg21.link/dcl.struct.bind">dcl.struct.bind</a>]</td> <td>dup</td> <td>Structured bindings and lambda capture</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2315"> <td><a href="https://cplusplus.github.io/CWG/issues/2315.html">2315</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD5</td> <td>What is the “corresponding special member” of a variant member?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2316"> <td><a href="https://cplusplus.github.io/CWG/issues/2316.html">2316</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>drafting</td> <td>Simplifying class conversions in conditional expressions</td> <td align="center">Not resolved</td> </tr> <tr id="2317"> <td><a href="https://cplusplus.github.io/CWG/issues/2317.html">2317</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>CD5</td> <td>Self-referential default member initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2318"> <td><a href="https://cplusplus.github.io/CWG/issues/2318.html">2318</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>CD5</td> <td>Nondeduced contexts in deduction from a <I>braced-init-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2319"> <td><a href="https://cplusplus.github.io/CWG/issues/2319.html">2319</a></td> + <td>[<a href="https://wg21.link/over.best.ics">over.best.ics</a>]</td> <td>drafting</td> <td>Nested brace initialization from same type</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2320"> <td><a href="https://cplusplus.github.io/CWG/issues/2320.html">2320</a></td> + <td>[<a href="https://wg21.link/stmt.if">stmt.if</a>]</td> <td>extension</td> <td><TT>constexpr if</TT> and boolean conversions</td> <td align="center">Extension</td> </tr> <tr id="2321"> <td><a href="https://cplusplus.github.io/CWG/issues/2321.html">2321</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD5</td> <td>Conditional operator and cv-qualified class prvalues</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2322"> <td><a href="https://cplusplus.github.io/CWG/issues/2322.html">2322</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD5</td> <td>Substitution failure and lexical order</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2323"> <td><a href="https://cplusplus.github.io/CWG/issues/2323.html">2323</a></td> + <td>[<a href="https://wg21.link/basic.types">basic.types</a>]</td> <td>C++20</td> <td>Expunge POD</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2324"> <td><a href="https://cplusplus.github.io/CWG/issues/2324.html">2324</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>drafting</td> <td>Size of base class subobject</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2325"> <td><a href="https://cplusplus.github.io/CWG/issues/2325.html">2325</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>drafting</td> <td><TT>std::launder</TT> and reuse of character buffers</td> <td align="center">Not resolved</td> </tr> <tr id="2326"> <td><a href="https://cplusplus.github.io/CWG/issues/2326.html">2326</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>dup</td> <td>Type deduction with initializer list containing ambiguous functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2327"> <td><a href="https://cplusplus.github.io/CWG/issues/2327.html">2327</a></td> + <td>[<a href="https://wg21.link/dcl.init">dcl.init</a>]</td> <td>drafting</td> <td>Copy elision for direct-initialization with a conversion function</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2328"> <td><a href="https://cplusplus.github.io/CWG/issues/2328.html">2328</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>drafting</td> <td>Unclear presentation style of template argument deduction rules</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2329"> <td><a href="https://cplusplus.github.io/CWG/issues/2329.html">2329</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>open</td> <td>Virtual base classes and generated assignment operators</td> <td align="center">Not resolved</td> </tr> <tr id="2330"> <td><a href="https://cplusplus.github.io/CWG/issues/2330.html">2330</a></td> + <td>[<a href="https://wg21.link/temp.spec">temp.spec</a>]</td> <td>CD5</td> <td>Missing references to variable templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2331"> <td><a href="https://cplusplus.github.io/CWG/issues/2331.html">2331</a></td> + <td>[<a href="https://wg21.link/basic.scope.class">basic.scope.class</a>]</td> <td>CD6</td> <td>Redundancy in description of class scope</td> <td class="na" align="center">N/A</td> </tr> <tr id="2332"> <td><a href="https://cplusplus.github.io/CWG/issues/2332.html">2332</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>CD5</td> <td><I>template-name</I> as <I>simple-type-name</I> vs injected-class-name</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2333"> <td><a href="https://cplusplus.github.io/CWG/issues/2333.html">2333</a></td> + <td>[<a href="https://wg21.link/lex.ccon">lex.ccon</a>]</td> <td>CD6</td> <td>Escape sequences in UTF-8 character literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2334"> <td><a href="https://cplusplus.github.io/CWG/issues/2334.html">2334</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>open</td> <td>Creation of objects by <TT>typeid</TT></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2335"> <td><a href="https://cplusplus.github.io/CWG/issues/2335.html">2335</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>drafting</td> <td>Deduced return types vs member types</td> <td align="center"> @@ -13849,1308 +16142,1526 @@ and <I>POD class</I></td> </tr> <tr id="2336"> <td><a href="https://cplusplus.github.io/CWG/issues/2336.html">2336</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>CD5</td> <td>Destructor characteristics vs potentially-constructed subobjects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2337"> <td><a href="https://cplusplus.github.io/CWG/issues/2337.html">2337</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>open</td> <td>Incorrect implication of logic ladder for conversion sequence tiebreakers</td> <td align="center">Not resolved</td> </tr> <tr id="2338"> <td><a href="https://cplusplus.github.io/CWG/issues/2338.html">2338</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD5</td> <td>Undefined behavior converting to short enums with fixed underlying types</td> <td class="full" align="center">Clang 12</td> </tr> <tr id="2339"> <td><a href="https://cplusplus.github.io/CWG/issues/2339.html">2339</a></td> + <td>[<a href="https://wg21.link/dcl.struct.bind">dcl.struct.bind</a>]</td> <td>CD5</td> <td>Underspecified template arguments in structured bindings</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2340"> <td><a href="https://cplusplus.github.io/CWG/issues/2340.html">2340</a></td> + <td>[<a href="https://wg21.link/dcl.struct.bind">dcl.struct.bind</a>]</td> <td>open</td> <td>Reference collapsing and structured bindings</td> <td align="center">Not resolved</td> </tr> <tr id="2341"> <td><a href="https://cplusplus.github.io/CWG/issues/2341.html">2341</a></td> + <td>[<a href="https://wg21.link/dcl.pre">dcl.pre</a>]</td> <td>CD5</td> <td>Structured bindings with static storage duration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2342"> <td><a href="https://cplusplus.github.io/CWG/issues/2342.html">2342</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>CD5</td> <td>Reference <TT>reinterpret_cast</TT> and pointer-interconvertibility</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2343"> <td><a href="https://cplusplus.github.io/CWG/issues/2343.html">2343</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>C++20</td> <td><TT>void*</TT> non-type template parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2344"> <td><a href="https://cplusplus.github.io/CWG/issues/2344.html">2344</a></td> + <td>[<a href="https://wg21.link/stmt.select">stmt.select</a>]</td> <td>NAD</td> <td>Redeclaration of names in <I>init-statement</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2345"> <td><a href="https://cplusplus.github.io/CWG/issues/2345.html">2345</a></td> + <td>[<a href="https://wg21.link/stmt.if">stmt.if</a>]</td> <td>CD5</td> <td>Jumping across initializers in <I>init-statement</I>s and <I>condition</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2346"> <td><a href="https://cplusplus.github.io/CWG/issues/2346.html">2346</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>CD5</td> <td>Local variables in default arguments</td> <td class="full" align="center">Clang 11</td> </tr> <tr id="2347"> <td><a href="https://cplusplus.github.io/CWG/issues/2347.html">2347</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>C++20</td> <td>Passing short scoped enumerations to ellipsis</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2348"> <td><a href="https://cplusplus.github.io/CWG/issues/2348.html">2348</a></td> + <td>[<a href="https://wg21.link/stmt.if">stmt.if</a>]</td> <td>NAD</td> <td>Non-templated <TT>constexpr if</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2349"> <td><a href="https://cplusplus.github.io/CWG/issues/2349.html">2349</a></td> + <td>[<a href="https://wg21.link/stmt">stmt</a>]</td> <td>NAD</td> <td>Class/enumeration names vs conditions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2350"> <td><a href="https://cplusplus.github.io/CWG/issues/2350.html">2350</a></td> + <td>[<a href="https://wg21.link/temp.deduct.partial">temp.deduct.partial</a>]</td> <td>NAD</td> <td>Forwarding references and deduction guides</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2351"> <td><a href="https://cplusplus.github.io/CWG/issues/2351.html">2351</a></td> + <td>[<a href="https://wg21.link/expr.type.conv">expr.type.conv</a>]</td> <td>CD5</td> <td><TT>void{}</TT></td> <td class="full" align="center">Clang 20</td> </tr> <tr id="2352"> <td><a href="https://cplusplus.github.io/CWG/issues/2352.html">2352</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD5</td> <td>Similar types and reference binding</td> <td class="full" align="center">Clang 10</td> </tr> <tr id="2353"> <td><a href="https://cplusplus.github.io/CWG/issues/2353.html">2353</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD5</td> <td>Potential results of a member access expression for a static data member</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="2354"> <td><a href="https://cplusplus.github.io/CWG/issues/2354.html">2354</a></td> + <td>[<a href="https://wg21.link/basic.align">basic.align</a>]</td> <td>CD5</td> <td>Extended alignment and object representation</td> <td class="full" align="center">Clang 15</td> </tr> <tr id="2355"> <td><a href="https://cplusplus.github.io/CWG/issues/2355.html">2355</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>CD6</td> <td>Deducing <I>noexcept-specifier</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2356"> <td><a href="https://cplusplus.github.io/CWG/issues/2356.html">2356</a></td> + <td>[<a href="https://wg21.link/over.match.funcs">over.match.funcs</a>]</td> <td>CD5</td> <td>Base class copy and move constructors should not be inherited</td> <td class="full" align="center">Clang 4</td> </tr> <tr id="2357"> <td><a href="https://cplusplus.github.io/CWG/issues/2357.html">2357</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>NAD</td> <td>Lookup in member function declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2358"> <td><a href="https://cplusplus.github.io/CWG/issues/2358.html">2358</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>CD5</td> <td>Explicit capture of value</td> <td class="full" align="center">Clang 16</td> </tr> <tr id="2359"> <td><a href="https://cplusplus.github.io/CWG/issues/2359.html">2359</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>CD5</td> <td>Unintended copy initialization with designated initializers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2360"> <td><a href="https://cplusplus.github.io/CWG/issues/2360.html">2360</a></td> + <td>[<a href="https://wg21.link/dcl.attr.unused">dcl.attr.unused</a>]</td> <td>CD5</td> <td><TT>[[maybe_unused]]</TT> and structured bindings</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2361"> <td><a href="https://cplusplus.github.io/CWG/issues/2361.html">2361</a></td> + <td>[<a href="https://wg21.link/csetjmp.syn">csetjmp.syn</a>]</td> <td>open</td> <td>Unclear description of <TT>longjmp</TT> undefined behavior</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2362"> <td><a href="https://cplusplus.github.io/CWG/issues/2362.html">2362</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.general">dcl.fct.def.general</a>]</td> <td>open</td> <td><TT>__func__</TT> should be <TT>constexpr</TT></td> <td align="center">Not resolved</td> </tr> <tr id="2363"> <td><a href="https://cplusplus.github.io/CWG/issues/2363.html">2363</a></td> + <td>[<a href="https://wg21.link/class.friend">class.friend</a>]</td> <td>NAD</td> <td>Opaque enumeration friend declarations</td> <td class="full" align="center">Clang 19</td> </tr> <tr id="2364"> <td><a href="https://cplusplus.github.io/CWG/issues/2364.html">2364</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>NAD</td> <td>Constant expressions, aggregate initialization, and modifications</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2365"> <td><a href="https://cplusplus.github.io/CWG/issues/2365.html">2365</a></td> + <td>[<a href="https://wg21.link/expr.dynamic.cast">expr.dynamic.cast</a>]</td> <td>CD5</td> <td>Confusing specification for <TT>dynamic_cast</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2366"> <td><a href="https://cplusplus.github.io/CWG/issues/2366.html">2366</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>CD5</td> <td>Can default initialization be constant initialization?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2367"> <td><a href="https://cplusplus.github.io/CWG/issues/2367.html">2367</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>NAD</td> <td>Lambdas in default arguments vs the ODR</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2368"> <td><a href="https://cplusplus.github.io/CWG/issues/2368.html">2368</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD5</td> <td>Differences in relational and three-way constant comparisons</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2369"> <td><a href="https://cplusplus.github.io/CWG/issues/2369.html">2369</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>CD6</td> <td>Ordering between constraints and substitution</td> <td class="partial" align="center">Partial</td> </tr> <tr id="2370"> <td><a href="https://cplusplus.github.io/CWG/issues/2370.html">2370</a></td> + <td>[<a href="https://wg21.link/basic.lookup.unqual">basic.lookup.unqual</a>]</td> <td>CD6</td> <td><TT>friend</TT> declarations of namespace-scope functions</td> <td class="none" align="center">No</td> </tr> <tr id="2371"> <td><a href="https://cplusplus.github.io/CWG/issues/2371.html">2371</a></td> + <td>[<a href="https://wg21.link/basic.def">basic.def</a>]</td> <td>CD5</td> <td>Use of the English term “attributes” is confusing</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2372"> <td><a href="https://cplusplus.github.io/CWG/issues/2372.html">2372</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD5</td> <td>Incorrect matching rules for block-scope <TT>extern</TT> declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2373"> <td><a href="https://cplusplus.github.io/CWG/issues/2373.html">2373</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>CD5</td> <td>Incorrect handling of static member function templates in partial ordering</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2374"> <td><a href="https://cplusplus.github.io/CWG/issues/2374.html">2374</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>C++20</td> <td>Overly permissive specification of <TT>enum</TT> direct-list-initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2375"> <td><a href="https://cplusplus.github.io/CWG/issues/2375.html">2375</a></td> + <td>[<a href="https://wg21.link/class.static.data">class.static.data</a>]</td> <td>NAD</td> <td>Multiple redeclarations of <TT>constexpr</TT> static data members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2376"> <td><a href="https://cplusplus.github.io/CWG/issues/2376.html">2376</a></td> + <td>[<a href="https://wg21.link/over.match.class.deduct">over.match.class.deduct</a>]</td> <td>CD5</td> <td>Class template argument deduction with array declarator</td> <td class="full" align="center">Clang 21</td> </tr> <tr id="2377"> <td><a href="https://cplusplus.github.io/CWG/issues/2377.html">2377</a></td> + <td>[<a href="https://wg21.link/over.match.viable">over.match.viable</a>]</td> <td>NAD</td> <td>Explicit copy constructor vs function viability</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2378"> <td><a href="https://cplusplus.github.io/CWG/issues/2378.html">2378</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>C++20</td> <td>Inconsistent grammar for reference <I>init-capture</I> of pack</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2379"> <td><a href="https://cplusplus.github.io/CWG/issues/2379.html">2379</a></td> + <td>[<a href="https://wg21.link/temp.friend">temp.friend</a>]</td> <td>CD5</td> <td>Missing prohibition against <TT>constexpr</TT> in <TT>friend</TT> declaration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2380"> <td><a href="https://cplusplus.github.io/CWG/issues/2380.html">2380</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD5</td> <td><I>capture-default</I> makes too many references odr-usable</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2381"> <td><a href="https://cplusplus.github.io/CWG/issues/2381.html">2381</a></td> + <td>[<a href="https://wg21.link/expr.type">expr.type</a>]</td> <td>CD5</td> <td>Composite pointer type of pointers to plain and noexcept member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2382"> <td><a href="https://cplusplus.github.io/CWG/issues/2382.html">2382</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD5</td> <td>Array allocation overhead for non-allocating placement <TT>new</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2383"> <td><a href="https://cplusplus.github.io/CWG/issues/2383.html">2383</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>NAD</td> <td>Variadic member functions of variadic class templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2384"> <td><a href="https://cplusplus.github.io/CWG/issues/2384.html">2384</a></td> + <td>[<a href="https://wg21.link/temp.deduct.conv">temp.deduct.conv</a>]</td> <td>CD5</td> <td>Conversion function templates and qualification conversions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2385"> <td><a href="https://cplusplus.github.io/CWG/issues/2385.html">2385</a></td> + <td>[<a href="https://wg21.link/expr.prim.id.qual">expr.prim.id.qual</a>]</td> <td>CD5</td> <td>Lookup for <I>conversion-function-id</I>s</td> <td class="na" align="center">N/A</td> </tr> <tr id="2386"> <td><a href="https://cplusplus.github.io/CWG/issues/2386.html">2386</a></td> + <td>[<a href="https://wg21.link/dcl.struct.bind">dcl.struct.bind</a>]</td> <td>CD5</td> <td><T>tuple_size</T> requirements for structured binding</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="2387"> <td><a href="https://cplusplus.github.io/CWG/issues/2387.html">2387</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD5</td> <td>Linkage of const-qualified variable template</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="2388"> <td><a href="https://cplusplus.github.io/CWG/issues/2388.html">2388</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>NAD</td> <td>Applicability of <I>contract-attribute-specifier</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2389"> <td><a href="https://cplusplus.github.io/CWG/issues/2389.html">2389</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>CD6</td> <td>Agreement of deduced and explicitly-specified variable types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2390"> <td><a href="https://cplusplus.github.io/CWG/issues/2390.html">2390</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>CD5</td> <td>Is the argument of <TT>__has_cpp_attribute</TT> macro-expanded?</td> <td class="full" align="center">Clang 14</td> </tr> <tr id="2391"> <td><a href="https://cplusplus.github.io/CWG/issues/2391.html">2391</a></td> + <td>[<a href="https://wg21.link/temp.variadic">temp.variadic</a>]</td> <td>dup</td> <td>Additional template parameters following pack expansion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2392"> <td><a href="https://cplusplus.github.io/CWG/issues/2392.html">2392</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++23</td> <td><I>new-expression</I> size check and constant evaluation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2393"> <td><a href="https://cplusplus.github.io/CWG/issues/2393.html">2393</a></td> + <td>[<a href="https://wg21.link/expr.pseudo">expr.pseudo</a>]</td> <td>NAD</td> <td>Pseudo-destructors and object lifetime</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2394"> <td><a href="https://cplusplus.github.io/CWG/issues/2394.html">2394</a></td> + <td>[<a href="https://wg21.link/class.default.ctor">class.default.ctor</a>]</td> <td>CD5</td> <td>Const-default-constructible for members</td> <td class="full" align="center">Clang 15</td> </tr> <tr class="open" id="2395"> <td><a href="https://cplusplus.github.io/CWG/issues/2395.html">2395</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>drafting</td> <td>Parameters following a pack expansion</td> <td align="center">Not resolved</td> </tr> <tr id="2396"> <td><a href="https://cplusplus.github.io/CWG/issues/2396.html">2396</a></td> + <td>[<a href="https://wg21.link/expr.prim.id.qual">expr.prim.id.qual</a>]</td> <td>CD6</td> <td>Lookup of names in complex <I>conversion-type-id</I>s</td> <td class="none" align="center">No</td> </tr> <tr id="2397"> <td><a href="https://cplusplus.github.io/CWG/issues/2397.html">2397</a></td> + <td>[<a href="https://wg21.link/dcl.array">dcl.array</a>]</td> <td>CD6</td> <td><TT>auto</TT> specifier for pointers and references to arrays</td> <td class="full" align="center">Clang 17</td> </tr> <tr class="open" id="2398"> <td><a href="https://cplusplus.github.io/CWG/issues/2398.html">2398</a></td> + <td>[<a href="https://wg21.link/temp.arg.template">temp.arg.template</a>]</td> <td>drafting</td> <td>Template template parameter matching and deduction</td> <td align="center">Not resolved</td> </tr> <tr id="2399"> <td><a href="https://cplusplus.github.io/CWG/issues/2399.html">2399</a></td> + <td>[<a href="https://wg21.link/expr.assign">expr.assign</a>]</td> <td>CD5</td> <td>Unclear referent of “expression” in <I>assignment-expression</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2400"> <td><a href="https://cplusplus.github.io/CWG/issues/2400.html">2400</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD5</td> <td>Constexpr virtual functions and temporary objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2401"> <td><a href="https://cplusplus.github.io/CWG/issues/2401.html">2401</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>C++20</td> <td>Array decay vs prohibition of subobject non-type arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2402"> <td><a href="https://cplusplus.github.io/CWG/issues/2402.html">2402</a></td> + <td>[<a href="https://wg21.link/lex.ccon">lex.ccon</a>]</td> <td>CD6</td> <td>When is the restriction to a single <I>c-char</I> in a Unicode literal enforced?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2403"> <td><a href="https://cplusplus.github.io/CWG/issues/2403.html">2403</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>drafting</td> <td>Temporary materialization and base/member initialization</td> <td align="center">Not resolved</td> </tr> <tr id="2404"> <td><a href="https://cplusplus.github.io/CWG/issues/2404.html">2404</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>CD5</td> <td><TT>[[no_unique_address]]</TT> and allocation order</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2405"> <td><a href="https://cplusplus.github.io/CWG/issues/2405.html">2405</a></td> + <td>[<a href="https://wg21.link/temp.dep.expr">temp.dep.expr</a>]</td> <td>CD6</td> <td>Additional type-dependent expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2406"> <td><a href="https://cplusplus.github.io/CWG/issues/2406.html">2406</a></td> + <td>[<a href="https://wg21.link/dcl.attr.fallthrough">dcl.attr.fallthrough</a>]</td> <td>CD5</td> <td><TT>[[fallthrough]]</TT> attribute and iteration statements</td> <td class="full" align="center">Clang 5</td> </tr> <tr id="2407"> <td><a href="https://cplusplus.github.io/CWG/issues/2407.html">2407</a></td> + <td>[<a href="https://wg21.link/diff">diff</a>]</td> <td>C++23</td> <td>Missing entry in Annex C for defaulted comparison operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2408"> <td><a href="https://cplusplus.github.io/CWG/issues/2408.html">2408</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>NAD</td> <td>Temporaries and previously-initialized elements in aggregate initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2409"> <td><a href="https://cplusplus.github.io/CWG/issues/2409.html">2409</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>drafting</td> <td>Explicit specializations of constexpr static data members</td> <td align="center">Not resolved</td> </tr> <tr id="2410"> <td><a href="https://cplusplus.github.io/CWG/issues/2410.html">2410</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++23</td> <td>Implicit calls of immediate functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2411"> <td><a href="https://cplusplus.github.io/CWG/issues/2411.html">2411</a></td> + <td>[<a href="https://wg21.link/temp.type">temp.type</a>]</td> <td>C++20</td> <td>Comparison of pointers to members in template non-type arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2412"> <td><a href="https://cplusplus.github.io/CWG/issues/2412.html">2412</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>review</td> <td>SFINAE vs undeduced placeholder type</td> <td align="center">Not resolved</td> </tr> <tr id="2413"> <td><a href="https://cplusplus.github.io/CWG/issues/2413.html">2413</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>CD6</td> <td><TT>typename</TT> in <I>conversion-function-id</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2414"> <td><a href="https://cplusplus.github.io/CWG/issues/2414.html">2414</a></td> + <td>[<a href="https://wg21.link/class.compare.default">class.compare.default</a>]</td> <td>C++20</td> <td>Unclear results if both member and friend <TT>operator<=></TT> are declared</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2415"> <td><a href="https://cplusplus.github.io/CWG/issues/2415.html">2415</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>NAD</td> <td><I>using-declaration</I>s vs copy assignment operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2416"> <td><a href="https://cplusplus.github.io/CWG/issues/2416.html">2416</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>C++20</td> <td>Explicit specializations vs <TT>constexpr</TT> and <TT>consteval</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2417"> <td><a href="https://cplusplus.github.io/CWG/issues/2417.html">2417</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>open</td> <td>Explicit instantiation and exception specifications</td> <td align="center">Not resolved</td> </tr> <tr id="2418"> <td><a href="https://cplusplus.github.io/CWG/issues/2418.html">2418</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD5</td> <td>Missing cases in definition of “usable in constant expressions”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2419"> <td><a href="https://cplusplus.github.io/CWG/issues/2419.html">2419</a></td> + <td>[<a href="https://wg21.link/expr.add">expr.add</a>]</td> <td>C++20</td> <td>Loss of generality treating pointers to objects as one-element arrays</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2420"> <td><a href="https://cplusplus.github.io/CWG/issues/2420.html">2420</a></td> + <td>[<a href="https://wg21.link/except.spec">except.spec</a>]</td> <td>dup</td> <td>Exception specifications in explicit instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2421"> <td><a href="https://cplusplus.github.io/CWG/issues/2421.html">2421</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>drafting</td> <td>Explicit instantiation of constrained member functions</td> <td align="center">Not resolved</td> </tr> <tr id="2422"> <td><a href="https://cplusplus.github.io/CWG/issues/2422.html">2422</a></td> + <td>[<a href="https://wg21.link/temp.deduct.guide">temp.deduct.guide</a>]</td> <td>C++20</td> <td>Incorrect grammar for <I>deduction-guide</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2423"> <td><a href="https://cplusplus.github.io/CWG/issues/2423.html">2423</a></td> + <td>[<a href="https://wg21.link/basic.pre">basic.pre</a>]</td> <td>NAD</td> <td>Typedefs, names, and entities</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2424"> <td><a href="https://cplusplus.github.io/CWG/issues/2424.html">2424</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++20</td> <td><TT>constexpr</TT> initialization requirements for variant members</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2425"> <td><a href="https://cplusplus.github.io/CWG/issues/2425.html">2425</a></td> + <td>[<a href="https://wg21.link/over.match.class.deduct">over.match.class.deduct</a>]</td> <td>open</td> <td>Confusing wording for deduction from a type</td> <td align="center">Not resolved</td> </tr> <tr id="2426"> <td><a href="https://cplusplus.github.io/CWG/issues/2426.html">2426</a></td> + <td>[<a href="https://wg21.link/except.ctor">except.ctor</a>]</td> <td>C++20</td> <td>Reference to destructor that cannot be invoked</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2427"> <td><a href="https://cplusplus.github.io/CWG/issues/2427.html">2427</a></td> + <td>[<a href="https://wg21.link/expr.assign">expr.assign</a>]</td> <td>C++20</td> <td>Deprecation of volatile operands and unevaluated contexts</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2428"> <td><a href="https://cplusplus.github.io/CWG/issues/2428.html">2428</a></td> + <td>[<a href="https://wg21.link/temp.concept">temp.concept</a>]</td> <td>C++23</td> <td>Deprecating a concept</td> <td class="full" align="center">Clang 19</td> </tr> <tr id="2429"> <td><a href="https://cplusplus.github.io/CWG/issues/2429.html">2429</a></td> + <td>[<a href="https://wg21.link/stmt.dcl">stmt.dcl</a>]</td> <td>C++20</td> <td>Initialization of <TT>thread_local</TT> variables referenced by lambdas</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2430"> <td><a href="https://cplusplus.github.io/CWG/issues/2430.html">2430</a></td> + <td>[<a href="https://wg21.link/class.mem">class.mem</a>]</td> <td>C++20</td> <td>Completeness of return and parameter types of member functions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="2431"> <td><a href="https://cplusplus.github.io/CWG/issues/2431.html">2431</a></td> + <td>[<a href="https://wg21.link/basic.exec">basic.exec</a>]</td> <td>C++20</td> <td>Full-expressions and temporaries bound to references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2432"> <td><a href="https://cplusplus.github.io/CWG/issues/2432.html">2432</a></td> + <td>[<a href="https://wg21.link/class.spaceship">class.spaceship</a>]</td> <td>C++20</td> <td>Return types for defaulted <TT><=></TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2433"> <td><a href="https://cplusplus.github.io/CWG/issues/2433.html">2433</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>C++20</td> <td>Variable templates in the ODR</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2434"> <td><a href="https://cplusplus.github.io/CWG/issues/2434.html">2434</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>review</td> <td>Mandatory copy elision vs non-class objects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2435"> <td><a href="https://cplusplus.github.io/CWG/issues/2435.html">2435</a></td> + <td>[<a href="https://wg21.link/temp.spec">temp.spec</a>]</td> <td>open</td> <td>Alias template specializations</td> <td align="center">Not resolved</td> </tr> <tr id="2436"> <td><a href="https://cplusplus.github.io/CWG/issues/2436.html">2436</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.coroutine">dcl.fct.def.coroutine</a>]</td> <td>C++20</td> <td>Copy semantics of coroutine parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2437"> <td><a href="https://cplusplus.github.io/CWG/issues/2437.html">2437</a></td> + <td>[<a href="https://wg21.link/class.spaceship">class.spaceship</a>]</td> <td>C++20</td> <td>Conversion of <TT>std::strong_ordering</TT> in a defaulted <TT>operator<=></TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2438"> <td><a href="https://cplusplus.github.io/CWG/issues/2438.html">2438</a></td> + <td>[<a href="https://wg21.link/conv.qual">conv.qual</a>]</td> <td>open</td> <td>Problems in the specification of qualification conversions</td> <td align="center">Not resolved</td> </tr> <tr id="2439"> <td><a href="https://cplusplus.github.io/CWG/issues/2439.html">2439</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++20</td> <td>Undefined term in definition of “usable in constant expressions”</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2440"> <td><a href="https://cplusplus.github.io/CWG/issues/2440.html">2440</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++23</td> <td>Allocation in core constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2441"> <td><a href="https://cplusplus.github.io/CWG/issues/2441.html">2441</a></td> + <td>[<a href="https://wg21.link/dcl.inline">dcl.inline</a>]</td> <td>C++20</td> <td>Inline function parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2442"> <td><a href="https://cplusplus.github.io/CWG/issues/2442.html">2442</a></td> + <td>[<a href="https://wg21.link/over.match.viable">over.match.viable</a>]</td> <td>C++20</td> <td>Incorrect requirement for default arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2443"> <td><a href="https://cplusplus.github.io/CWG/issues/2443.html">2443</a></td> + <td>[<a href="https://wg21.link/module.interface">module.interface</a>]</td> <td>C++23</td> <td>Meaningless template exports</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2444"> <td><a href="https://cplusplus.github.io/CWG/issues/2444.html">2444</a></td> + <td>[<a href="https://wg21.link/basic.start.dynamic">basic.start.dynamic</a>]</td> <td>drafting</td> <td>Constant expressions in initialization odr-use</td> <td align="center">Not resolved</td> </tr> <tr id="2445"> <td><a href="https://cplusplus.github.io/CWG/issues/2445.html">2445</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>C++20</td> <td>Partial ordering with rewritten candidates</td> <td class="full" align="center">Clang 19</td> </tr> <tr id="2446"> <td><a href="https://cplusplus.github.io/CWG/issues/2446.html">2446</a></td> + <td>[<a href="https://wg21.link/temp.dep.expr">temp.dep.expr</a>]</td> <td>C++20</td> <td>Questionable type-dependency of <I>concept-id</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2447"> <td><a href="https://cplusplus.github.io/CWG/issues/2447.html">2447</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto">dcl.spec.auto</a>]</td> <td>C++20</td> <td>Unintended description of abbreviated function templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2448"> <td><a href="https://cplusplus.github.io/CWG/issues/2448.html">2448</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>CD6</td> <td>Cv-qualification of arithmetic types and deprecation of volatile</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2449"> <td><a href="https://cplusplus.github.io/CWG/issues/2449.html">2449</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>extension</td> <td>Thunks as an implementation technique for pointers to virtual functions</td> <td align="center">Extension</td> </tr> <tr id="2450"> <td><a href="https://cplusplus.github.io/CWG/issues/2450.html">2450</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>CD7</td> <td><I>braced-init-list</I> as a <I>template-argument</I></td> <td class="full" align="center">Clang 18</td> </tr> <tr id="2451"> <td><a href="https://cplusplus.github.io/CWG/issues/2451.html">2451</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.coroutine">dcl.fct.def.coroutine</a>]</td> <td>C++23</td> <td><I>promise</I><TT>.unhandled_exception()</TT> and final suspend point</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2452"> <td><a href="https://cplusplus.github.io/CWG/issues/2452.html">2452</a></td> + <td>[<a href="https://wg21.link/stmt.return.coroutine">stmt.return.coroutine</a>]</td> <td>CD6</td> <td>Flowing off the end of a coroutine</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2453"> <td><a href="https://cplusplus.github.io/CWG/issues/2453.html">2453</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto.general">dcl.spec.auto.general</a>]</td> <td>NAD</td> <td>Deduced return types and coroutine lambdas</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2454"> <td><a href="https://cplusplus.github.io/CWG/issues/2454.html">2454</a></td> + <td>[<a href="https://wg21.link/expr.await">expr.await</a>]</td> <td>NAD</td> <td>Tail recursion and coroutine symmetric transfer</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2455"> <td><a href="https://cplusplus.github.io/CWG/issues/2455.html">2455</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>CD6</td> <td>Concatenation of string literals vs translation phases 5 and 6</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2456"> <td><a href="https://cplusplus.github.io/CWG/issues/2456.html">2456</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Viable user-defined conversions in converted constant expressions</td> <td align="center">Not resolved</td> </tr> <tr id="2457"> <td><a href="https://cplusplus.github.io/CWG/issues/2457.html">2457</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>CD6</td> <td>Unexpanded parameter packs don't make a function type dependent</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2458"> <td><a href="https://cplusplus.github.io/CWG/issues/2458.html">2458</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>CD6</td> <td>Value category of expressions denoting non-static member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2459"> <td><a href="https://cplusplus.github.io/CWG/issues/2459.html">2459</a></td> + <td>[<a href="https://wg21.link/temp.arg.nontype">temp.arg.nontype</a>]</td> <td>CD7</td> <td>Template parameter initialization</td> <td class="full" align="center">Clang 18</td> </tr> <tr id="2460"> <td><a href="https://cplusplus.github.io/CWG/issues/2460.html">2460</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>CD6</td> <td>C language linkage and constrained non-template friends</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2461"> <td><a href="https://cplusplus.github.io/CWG/issues/2461.html">2461</a></td> + <td>[<a href="https://wg21.link/temp.res">temp.res</a>]</td> <td>CD6</td> <td>Diagnosing non-<TT>bool</TT> type constraints</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2462"> <td><a href="https://cplusplus.github.io/CWG/issues/2462.html">2462</a></td> + <td>[<a href="https://wg21.link/temp.res.general">temp.res.general</a>]</td> <td>open</td> <td>Problems with the omission of the <TT>typename</TT> keyword</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2463"> <td><a href="https://cplusplus.github.io/CWG/issues/2463.html">2463</a></td> + <td>[<a href="https://wg21.link/class.prop">class.prop</a>]</td> <td>open</td> <td>Trivial copyability and unions with non-trivial members</td> <td align="center">Not resolved</td> </tr> <tr id="2464"> <td><a href="https://cplusplus.github.io/CWG/issues/2464.html">2464</a></td> + <td>[<a href="https://wg21.link/ptr.launder">ptr.launder</a>]</td> <td>CD6</td> <td>Constexpr launder and unions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2465"> <td><a href="https://cplusplus.github.io/CWG/issues/2465.html">2465</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.coroutine">dcl.fct.def.coroutine</a>]</td> <td>CD6</td> <td>Coroutine parameters passed to a promise constructor</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2466"> <td><a href="https://cplusplus.github.io/CWG/issues/2466.html">2466</a></td> + <td>[<a href="https://wg21.link/expr.await">expr.await</a>]</td> <td>CD6</td> <td><TT>co_await</TT> should be a single evaluation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2467"> <td><a href="https://cplusplus.github.io/CWG/issues/2467.html">2467</a></td> + <td>[<a href="https://wg21.link/over.match.class.deduct">over.match.class.deduct</a>]</td> <td>drafting</td> <td>CTAD for alias templates and the deducible check</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2468"> <td><a href="https://cplusplus.github.io/CWG/issues/2468.html">2468</a></td> + <td>[<a href="https://wg21.link/temp.res.general">temp.res.general</a>]</td> <td>open</td> <td>Omission of the <TT>typename</TT> keyword in a member template parameter list</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2469"> <td><a href="https://cplusplus.github.io/CWG/issues/2469.html">2469</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>drafting</td> <td>Implicit object creation vs constant expressions</td> <td align="center">Not resolved</td> </tr> <tr id="2470"> <td><a href="https://cplusplus.github.io/CWG/issues/2470.html">2470</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>CD6</td> <td>Multiple array objects providing storage for one object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2471"> <td><a href="https://cplusplus.github.io/CWG/issues/2471.html">2471</a></td> + <td>[<a href="https://wg21.link/over.match.class.deduct">over.match.class.deduct</a>]</td> <td>drafting</td> <td>Nested class template argument deduction</td> <td align="center">Not resolved</td> </tr> <tr id="2472"> <td><a href="https://cplusplus.github.io/CWG/issues/2472.html">2472</a></td> + <td>[<a href="https://wg21.link/expr.await">expr.await</a>]</td> <td>NAD</td> <td>Value categories in <I>await-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2473"> <td><a href="https://cplusplus.github.io/CWG/issues/2473.html">2473</a></td> + <td>[<a href="https://wg21.link/expr.prim.id.dtor">expr.prim.id.dtor</a>]</td> <td>open</td> <td>Parentheses in pseudo-destructor calls</td> <td align="center">Not resolved</td> </tr> <tr id="2474"> <td><a href="https://cplusplus.github.io/CWG/issues/2474.html">2474</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>CD6</td> <td>Cv-qualification and deletion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2475"> <td><a href="https://cplusplus.github.io/CWG/issues/2475.html">2475</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>C++23</td> <td>Object declarations of type <I>cv</I> <TT>void</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2476"> <td><a href="https://cplusplus.github.io/CWG/issues/2476.html">2476</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto.general">dcl.spec.auto.general</a>]</td> <td>CD7</td> <td><I>placeholder-type-specifier</I>s and function declarators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2477"> <td><a href="https://cplusplus.github.io/CWG/issues/2477.html">2477</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>CD6</td> <td>Defaulted vs deleted copy constructors/assignment operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2478"> <td><a href="https://cplusplus.github.io/CWG/issues/2478.html">2478</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>C++23</td> <td>Properties of explicit specializations of implicitly-instantiated class templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2479"> <td><a href="https://cplusplus.github.io/CWG/issues/2479.html">2479</a></td> + <td>[<a href="https://wg21.link/basic.start.main">basic.start.main</a>]</td> <td>CD6</td> <td>Missing specifications for <TT>consteval</TT> and <TT>constinit</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2480"> <td><a href="https://cplusplus.github.io/CWG/issues/2480.html">2480</a></td> + <td>[<a href="https://wg21.link/basic.lookup.general">basic.lookup.general</a>]</td> <td>drafting</td> <td>Lookup for enumerators in modules</td> <td align="center">Not resolved</td> </tr> <tr id="2481"> <td><a href="https://cplusplus.github.io/CWG/issues/2481.html">2481</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD6</td> <td>Cv-qualification of temporary to which a reference is bound</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2482"> <td><a href="https://cplusplus.github.io/CWG/issues/2482.html">2482</a></td> + <td>[<a href="https://wg21.link/bit.cast">bit.cast</a>]</td> <td>CD6</td> <td><TT>bit_cast</TT> and indeterminate values</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2483"> <td><a href="https://cplusplus.github.io/CWG/issues/2483.html">2483</a></td> + <td>[<a href="https://wg21.link/dcl.link">dcl.link</a>]</td> <td>C++23</td> <td>Language linkage of static member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2484"> <td><a href="https://cplusplus.github.io/CWG/issues/2484.html">2484</a></td> + <td>[<a href="https://wg21.link/conv.prom">conv.prom</a>]</td> <td>CD6</td> <td><TT>char8_t</TT> and <TT>char16_t</TT> in integral promotions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2485"> <td><a href="https://cplusplus.github.io/CWG/issues/2485.html">2485</a></td> + <td>[<a href="https://wg21.link/conv.prom">conv.prom</a>]</td> <td>CD7</td> <td>Bit-fields in integral promotions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2486"> <td><a href="https://cplusplus.github.io/CWG/issues/2486.html">2486</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD6</td> <td>Call to <TT>noexcept</TT> function via <TT>noexcept(false)</TT> pointer/lvalue</td> <td class="full" align="center">Clang 4 (C++17 onwards)</td> </tr> <tr class="open" id="2487"> <td><a href="https://cplusplus.github.io/CWG/issues/2487.html">2487</a></td> + <td>[<a href="https://wg21.link/temp.dep.expr">temp.dep.expr</a>]</td> <td>drafting</td> <td>Type dependence of function-style cast to incomplete array type</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2488"> <td><a href="https://cplusplus.github.io/CWG/issues/2488.html">2488</a></td> + <td>[<a href="https://wg21.link/basic.scope.scope">basic.scope.scope</a>]</td> <td>open</td> <td>Overloading virtual functions and functions with trailing <I>requires-clause</I>s</td> <td align="center">Not resolved</td> </tr> <tr id="2489"> <td><a href="https://cplusplus.github.io/CWG/issues/2489.html">2489</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>C++23</td> <td>Storage provided by array of <TT>char</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2490"> <td><a href="https://cplusplus.github.io/CWG/issues/2490.html">2490</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD6</td> <td>Restrictions on destruction in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2491"> <td><a href="https://cplusplus.github.io/CWG/issues/2491.html">2491</a></td> + <td>[<a href="https://wg21.link/module.interface">module.interface</a>]</td> <td>CD6</td> <td>Export of typedef after its first declaration</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2492"> <td><a href="https://cplusplus.github.io/CWG/issues/2492.html">2492</a></td> + <td>[<a href="https://wg21.link/over.ics.list">over.ics.list</a>]</td> <td>open</td> <td>Comparing user-defined conversion sequences in list-initialization</td> <td align="center">Not resolved</td> </tr> <tr id="2493"> <td><a href="https://cplusplus.github.io/CWG/issues/2493.html">2493</a></td> + <td>[<a href="https://wg21.link/dcl.spec.auto.general">dcl.spec.auto.general</a>]</td> <td>dup</td> <td><TT>auto</TT> as a <I>conversion-type-id</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2494"> <td><a href="https://cplusplus.github.io/CWG/issues/2494.html">2494</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD6</td> <td>Multiple definitions of non-odr-used entities</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2495"> <td><a href="https://cplusplus.github.io/CWG/issues/2495.html">2495</a></td> + <td>[<a href="https://wg21.link/stmt.return">stmt.return</a>]</td> <td>open</td> <td>Glvalue result of a function call</td> <td align="center">Not resolved</td> </tr> <tr id="2496"> <td><a href="https://cplusplus.github.io/CWG/issues/2496.html">2496</a></td> + <td>[<a href="https://wg21.link/class.virtual">class.virtual</a>]</td> <td>CD6</td> <td><I>ref-qualifier</I>s and virtual overriding</td> <td class="full" align="center">Clang 21</td> </tr> <tr class="open" id="2497"> <td><a href="https://cplusplus.github.io/CWG/issues/2497.html">2497</a></td> + <td>[<a href="https://wg21.link/temp.point">temp.point</a>]</td> <td>drafting</td> <td>Points of instantiation for constexpr function templates</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2498"> <td><a href="https://cplusplus.github.io/CWG/issues/2498.html">2498</a></td> + <td>[<a href="https://wg21.link/temp.deduct.general">temp.deduct.general</a>]</td> <td>open</td> <td>Partial specialization failure and the immediate context</td> <td align="center">Not resolved</td> </tr> <tr id="2499"> <td><a href="https://cplusplus.github.io/CWG/issues/2499.html">2499</a></td> + <td>[<a href="https://wg21.link/basic.compound">basic.compound</a>]</td> <td>CD6</td> <td>Inconsistency in definition of pointer-interconvertibility</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2500"> <td><a href="https://cplusplus.github.io/CWG/issues/2500.html">2500</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>extension</td> <td><TT>noexcept(false)</TT> functions and <TT>noexcept</TT> expressions</td> <td align="center">Extension</td> </tr> <tr class="open" id="2501"> <td><a href="https://cplusplus.github.io/CWG/issues/2501.html">2501</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>drafting</td> <td>Explicit instantiation and trailing <I>requires-clause</I>s</td> <td align="center">Not resolved</td> </tr> <tr id="2502"> <td><a href="https://cplusplus.github.io/CWG/issues/2502.html">2502</a></td> + <td>[<a href="https://wg21.link/basic.scope.block">basic.scope.block</a>]</td> <td>CD6</td> <td>Unintended declaration conflicts in nested statement scopes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2503"> <td><a href="https://cplusplus.github.io/CWG/issues/2503.html">2503</a></td> + <td>[<a href="https://wg21.link/expr.prim.id">expr.prim.id</a>]</td> <td>drafting</td> <td>Unclear relationship among name, qualified name, and unqualified name</td> <td align="center">Not resolved</td> </tr> <tr id="2504"> <td><a href="https://cplusplus.github.io/CWG/issues/2504.html">2504</a></td> + <td>[<a href="https://wg21.link/class.inhctor.init">class.inhctor.init</a>]</td> <td>CD7</td> <td>Inheriting constructors from virtual base classes</td> <td class="none" align="center">No</td> </tr> <tr class="open" id="2505"> <td><a href="https://cplusplus.github.io/CWG/issues/2505.html">2505</a></td> + <td>[<a href="https://wg21.link/namespace.unnamed">namespace.unnamed</a>]</td> <td>drafting</td> <td>Nested unnamed namespace of inline unnamed namespace</td> <td align="center">Not resolved</td> </tr> <tr id="2506"> <td><a href="https://cplusplus.github.io/CWG/issues/2506.html">2506</a></td> + <td>[<a href="https://wg21.link/dcl.struct.bind">dcl.struct.bind</a>]</td> <td>CD6</td> <td>Structured bindings and array cv-qualifiers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2507"> <td><a href="https://cplusplus.github.io/CWG/issues/2507.html">2507</a></td> + <td>[<a href="https://wg21.link/over.oper.general">over.oper.general</a>]</td> <td>CD6</td> <td>Default arguments for <TT>operator[]</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2508"> <td><a href="https://cplusplus.github.io/CWG/issues/2508.html">2508</a></td> + <td>[<a href="https://wg21.link/temp.local">temp.local</a>]</td> <td>C++23</td> <td>Restrictions on uses of template parameter names</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2509"> <td><a href="https://cplusplus.github.io/CWG/issues/2509.html">2509</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.general">expr.prim.lambda.general</a>]</td> <td>CD6</td> <td><I>decl-specifier-seq</I> in <I>lambda-specifiers</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2510"> <td><a href="https://cplusplus.github.io/CWG/issues/2510.html">2510</a></td> + <td>[<a href="https://wg21.link/class.mem.general">class.mem.general</a>]</td> <td>NAD</td> <td><I>noexcept-specifier</I> of friend function vs class completeness</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2511"> <td><a href="https://cplusplus.github.io/CWG/issues/2511.html">2511</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>CD6</td> <td>cv-qualified bit-fields</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2512"> <td><a href="https://cplusplus.github.io/CWG/issues/2512.html">2512</a></td> + <td>[<a href="https://wg21.link/expr.typeid">expr.typeid</a>]</td> <td>NAD</td> <td><TT>typeid</TT> and incomplete class types</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr class="open" id="2513"> <td><a href="https://cplusplus.github.io/CWG/issues/2513.html">2513</a></td> + <td>[<a href="https://wg21.link/class.conv.fct">class.conv.fct</a>]</td> <td>open</td> <td>Ambiguity with <I>requires-clause</I> and <I>operator-function-id</I></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2514"> <td><a href="https://cplusplus.github.io/CWG/issues/2514.html">2514</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>open</td> <td>Modifying const subobjects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2515"> <td><a href="https://cplusplus.github.io/CWG/issues/2515.html">2515</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>open</td> <td>Result of a function call</td> <td align="center">Not resolved</td> </tr> <tr id="2516"> <td><a href="https://cplusplus.github.io/CWG/issues/2516.html">2516</a></td> + <td>[<a href="https://wg21.link/basic.scope.pdecl">basic.scope.pdecl</a>]</td> <td>C++23</td> <td>Locus of <I>enum-specifier</I> or <I>opaque-enum-declaration</I></td> <td class="full" align="center">Clang 3.0</td> </tr> <tr id="2517"> <td><a href="https://cplusplus.github.io/CWG/issues/2517.html">2517</a></td> + <td>[<a href="https://wg21.link/expr.prim.req.nested">expr.prim.req.nested</a>]</td> <td>C++23</td> <td>Useless restriction on use of parameter in <I>constraint-expression</I></td> <td class="full" align="center">Clang 21</td> </tr> <tr id="2518"> <td><a href="https://cplusplus.github.io/CWG/issues/2518.html">2518</a></td> + <td>[<a href="https://wg21.link/intro.compliance.general">intro.compliance.general</a>]</td> <td>C++23</td> <td>Conformance requirements and <TT>#error</TT>/<TT>#warning</TT></td> <td class="full" align="center">Clang 17</td> </tr> <tr id="2519"> <td><a href="https://cplusplus.github.io/CWG/issues/2519.html">2519</a></td> + <td>[<a href="https://wg21.link/basic.types.general">basic.types.general</a>]</td> <td>CD7</td> <td>Object representation of a bit-field</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2520"> <td><a href="https://cplusplus.github.io/CWG/issues/2520.html">2520</a></td> + <td>[<a href="https://wg21.link/defns.signature.templ">defns.signature.templ</a>]</td> <td>C++23</td> <td>Template signature and default template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2521"> <td><a href="https://cplusplus.github.io/CWG/issues/2521.html">2521</a></td> + <td>[<a href="https://wg21.link/over.literal">over.literal</a>]</td> <td>C++23</td> <td>User-defined literals and reserved identifiers</td> <td class="full" align="center">Clang 17</td> </tr> <tr class="open" id="2522"> <td><a href="https://cplusplus.github.io/CWG/issues/2522.html">2522</a></td> + <td>[<a href="https://wg21.link/cpp.concat">cpp.concat</a>]</td> <td>open</td> <td>Removing placemarker tokens and retention of whitespace</td> <td align="center">Not resolved</td> </tr> <tr id="2523"> <td><a href="https://cplusplus.github.io/CWG/issues/2523.html">2523</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++23</td> <td>Undefined behavior via omitted destructor call in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2524"> <td><a href="https://cplusplus.github.io/CWG/issues/2524.html">2524</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>NAD</td> <td>Distinguishing user-defined conversion sequences by <I>ref-qualifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2525"> <td><a href="https://cplusplus.github.io/CWG/issues/2525.html">2525</a></td> + <td>[<a href="https://wg21.link/over.best.ics.general">over.best.ics.general</a>]</td> <td>open</td> <td>Incorrect definition of implicit conversion sequence</td> <td align="center">Not resolved</td> </tr> <tr id="2526"> <td><a href="https://cplusplus.github.io/CWG/issues/2526.html">2526</a></td> + <td>[<a href="https://wg21.link/expr.rel">expr.rel</a>]</td> <td>C++23</td> <td>Relational comparison of <TT>void*</TT> pointers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2527"> <td><a href="https://cplusplus.github.io/CWG/issues/2527.html">2527</a></td> + <td>[<a href="https://wg21.link/dcl.attr.nouniqueaddr">dcl.attr.nouniqueaddr</a>]</td> <td>NAD</td> <td>Non-class potentially-overlapping objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2528"> <td><a href="https://cplusplus.github.io/CWG/issues/2528.html">2528</a></td> + <td>[<a href="https://wg21.link/expr.arith.conv">expr.arith.conv</a>]</td> <td>C++23</td> <td>Three-way comparison and the usual arithmetic conversions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2529"> <td><a href="https://cplusplus.github.io/CWG/issues/2529.html">2529</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++23</td> <td>Constant destruction of constexpr references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2530"> <td><a href="https://cplusplus.github.io/CWG/issues/2530.html">2530</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>C++23</td> <td>Multiple definitions of enumerators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2531"> <td><a href="https://cplusplus.github.io/CWG/issues/2531.html">2531</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>CD7</td> <td>Static data members redeclared as constexpr</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2532"> <td><a href="https://cplusplus.github.io/CWG/issues/2532.html">2532</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>open</td> <td>Kind of pointer value returned by <TT>new T[0]</TT></td> <td align="center">Not resolved</td> </tr> <tr id="2533"> <td><a href="https://cplusplus.github.io/CWG/issues/2533.html">2533</a></td> + <td>[<a href="https://wg21.link/basic.stc">basic.stc</a>]</td> <td>CD7</td> <td>Storage duration of implicitly created objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2534"> <td><a href="https://cplusplus.github.io/CWG/issues/2534.html">2534</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>CD6</td> <td>Value category of pseudo-destructor expression</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2535"> <td><a href="https://cplusplus.github.io/CWG/issues/2535.html">2535</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>CD6</td> <td>Type punning in class member access</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2536"> <td><a href="https://cplusplus.github.io/CWG/issues/2536.html">2536</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Partially initialized variables during constant initialization</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2537"> <td><a href="https://cplusplus.github.io/CWG/issues/2537.html">2537</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>drafting</td> <td>Overbroad grammar for <I>parameter-declaration</I></td> <td align="center">Not resolved</td> </tr> <tr id="2538"> <td><a href="https://cplusplus.github.io/CWG/issues/2538.html">2538</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>C++23</td> <td>Can standard attributes be syntactically ignored?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2539"> <td><a href="https://cplusplus.github.io/CWG/issues/2539.html">2539</a></td> + <td>[<a href="https://wg21.link/class.spaceship">class.spaceship</a>]</td> <td>C++23</td> <td>Three-way comparison requiring strong ordering for floating-point types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2540"> <td><a href="https://cplusplus.github.io/CWG/issues/2540.html">2540</a></td> + <td>[<a href="https://wg21.link/lex.ccon">lex.ccon</a>]</td> <td>CD6</td> <td>Unspecified interpretation of <I>numeric-escape-sequence</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2541"> <td><a href="https://cplusplus.github.io/CWG/issues/2541.html">2541</a></td> + <td>[<a href="https://wg21.link/module.unit">module.unit</a>]</td> <td>open</td> <td>Linkage specifications, module purview, and module attachment</td> <td align="center">Not resolved</td> </tr> <tr id="2542"> <td><a href="https://cplusplus.github.io/CWG/issues/2542.html">2542</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD7</td> <td>Is a closure type a structural type?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2543"> <td><a href="https://cplusplus.github.io/CWG/issues/2543.html">2543</a></td> + <td>[<a href="https://wg21.link/dcl.constinit">dcl.constinit</a>]</td> <td>C++23</td> <td><TT>constinit</TT> and optimized dynamic initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2544"> <td><a href="https://cplusplus.github.io/CWG/issues/2544.html">2544</a></td> + <td>[<a href="https://wg21.link/basic.compound">basic.compound</a>]</td> <td>open</td> <td>Address of past-the-end of a potentially-overlapping subobject</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2545"> <td><a href="https://cplusplus.github.io/CWG/issues/2545.html">2545</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Transparently replacing objects in constant expressions</td> <td align="center">Not resolved</td> </tr> <tr id="2546"> <td><a href="https://cplusplus.github.io/CWG/issues/2546.html">2546</a></td> + <td>[<a href="https://wg21.link/class.compare.secondary">class.compare.secondary</a>]</td> <td>CD7</td> <td>Defaulted secondary comparison operators defined as deleted</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2547"> <td><a href="https://cplusplus.github.io/CWG/issues/2547.html">2547</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD7</td> <td>Defaulted comparison operator function for non-classes</td> <td class="full" align="center">Clang 20</td> </tr> <tr id="2548"> <td><a href="https://cplusplus.github.io/CWG/issues/2548.html">2548</a></td> + <td>[<a href="https://wg21.link/expr.add">expr.add</a>]</td> <td>NAD</td> <td>Array prvalues and additive operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2549"> <td><a href="https://cplusplus.github.io/CWG/issues/2549.html">2549</a></td> + <td>[<a href="https://wg21.link/expr.prim.id.qual">expr.prim.id.qual</a>]</td> <td>CD7</td> <td>Implicitly moving the operand of a <I>throw-expression</I> in unevaluated contexts</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2550"> <td><a href="https://cplusplus.github.io/CWG/issues/2550.html">2550</a></td> + <td>[<a href="https://wg21.link/dcl.ref">dcl.ref</a>]</td> <td>CD7</td> <td>Type "reference to <I>cv</I> <TT>void</TT>" outside of a declarator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2551"> <td><a href="https://cplusplus.github.io/CWG/issues/2551.html">2551</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>review</td> <td>"Refers to allocated storage" has no meaning</td> <td align="center">Not resolved</td> </tr> <tr id="2552"> <td><a href="https://cplusplus.github.io/CWG/issues/2552.html">2552</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>Constant evaluation of non-defining variable declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2553"> <td><a href="https://cplusplus.github.io/CWG/issues/2553.html">2553</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>review</td> <td>Restrictions on explicit object member functions</td> <td align="center"> @@ -15161,6 +17672,7 @@ and <I>POD class</I></td> </tr> <tr class="open" id="2554"> <td><a href="https://cplusplus.github.io/CWG/issues/2554.html">2554</a></td> + <td>[<a href="https://wg21.link/class.virtual">class.virtual</a>]</td> <td>review</td> <td>Overriding virtual functions, also with explicit object parameters</td> <td align="center"> @@ -15171,66 +17683,77 @@ and <I>POD class</I></td> </tr> <tr class="open" id="2555"> <td><a href="https://cplusplus.github.io/CWG/issues/2555.html">2555</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>tentatively ready</td> <td>Ineffective redeclaration prevention for <I>using-declarator</I>s</td> <td align="center">Not resolved</td> </tr> <tr id="2556"> <td><a href="https://cplusplus.github.io/CWG/issues/2556.html">2556</a></td> + <td>[<a href="https://wg21.link/stmt.return.coroutine">stmt.return.coroutine</a>]</td> <td>CD7</td> <td>Unusable <TT>promise::return_void</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2557"> <td><a href="https://cplusplus.github.io/CWG/issues/2557.html">2557</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>review</td> <td>Class member access referring to an unrelated class</td> <td align="center">Not resolved</td> </tr> <tr id="2558"> <td><a href="https://cplusplus.github.io/CWG/issues/2558.html">2558</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++23</td> <td>Uninitialized subobjects as a result of an immediate invocation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2559"> <td><a href="https://cplusplus.github.io/CWG/issues/2559.html">2559</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Defaulted consteval functions</td> <td align="center">Not resolved</td> </tr> <tr id="2560"> <td><a href="https://cplusplus.github.io/CWG/issues/2560.html">2560</a></td> + <td>[<a href="https://wg21.link/expr.prim.req.general">expr.prim.req.general</a>]</td> <td>CD7</td> <td>Parameter type determination in a <I>requirement-parameter-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2561"> <td><a href="https://cplusplus.github.io/CWG/issues/2561.html">2561</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD7</td> <td>Conversion to function pointer for lambda with explicit object parameter</td> <td class="none" align="center">No</td> </tr> <tr class="open" id="2562"> <td><a href="https://cplusplus.github.io/CWG/issues/2562.html">2562</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.coroutine">dcl.fct.def.coroutine</a>]</td> <td>open</td> <td>Exceptions thrown during coroutine startup</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2563"> <td><a href="https://cplusplus.github.io/CWG/issues/2563.html">2563</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.coroutine">dcl.fct.def.coroutine</a>]</td> <td>review</td> <td>Initialization of coroutine result object</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2564"> <td><a href="https://cplusplus.github.io/CWG/issues/2564.html">2564</a></td> + <td>[<a href="https://wg21.link/over.call.object">over.call.object</a>]</td> <td>drafting</td> <td>Conversion to function pointer with an explicit object parameter</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2565"> <td><a href="https://cplusplus.github.io/CWG/issues/2565.html">2565</a></td> + <td>[<a href="https://wg21.link/expr.prim.req.general">expr.prim.req.general</a>]</td> <td>open</td> <td>Invalid types in the <I>parameter-declaration-clause</I> of a <I>requires-expression</I></td> <td align="center"> @@ -15241,1231 +17764,1435 @@ and <I>POD class</I></td> </tr> <tr class="open" id="2566"> <td><a href="https://cplusplus.github.io/CWG/issues/2566.html">2566</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>review</td> <td>Matching deallocation for uncaught exception</td> <td align="center">Not resolved</td> </tr> <tr id="2567"> <td><a href="https://cplusplus.github.io/CWG/issues/2567.html">2567</a></td> + <td>[<a href="https://wg21.link/class.member.lookup">class.member.lookup</a>]</td> <td>NAD</td> <td>Operator lookup ambiguity</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2568"> <td><a href="https://cplusplus.github.io/CWG/issues/2568.html">2568</a></td> + <td>[<a href="https://wg21.link/class.compare.default">class.compare.default</a>]</td> <td>CD7</td> <td>Access checking during synthesis of defaulted comparison operator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2569"> <td><a href="https://cplusplus.github.io/CWG/issues/2569.html">2569</a></td> + <td>[<a href="https://wg21.link/expr.prim.id.unqual">expr.prim.id.unqual</a>]</td> <td>CD6</td> <td>Use of <code>decltype(capture)</code> in a lambda's <I>parameter-declaration-clause</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2570"> <td><a href="https://cplusplus.github.io/CWG/issues/2570.html">2570</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD7</td> <td>Clarify constexpr for defaulted functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2571"> <td><a href="https://cplusplus.github.io/CWG/issues/2571.html">2571</a></td> + <td>[<a href="https://wg21.link/expr.sub">expr.sub</a>]</td> <td>CD6</td> <td>Evaluation order for subscripting</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2572"> <td><a href="https://cplusplus.github.io/CWG/issues/2572.html">2572</a></td> + <td>[<a href="https://wg21.link/over.over">over.over</a>]</td> <td>review</td> <td>Address of overloaded function with no target</td> <td align="center">Not resolved</td> </tr> <tr id="2573"> <td><a href="https://cplusplus.github.io/CWG/issues/2573.html">2573</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>CD7</td> <td>Undefined behavior when splicing results in a <I>universal-character-name</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2574"> <td><a href="https://cplusplus.github.io/CWG/issues/2574.html">2574</a></td> + <td>[<a href="https://wg21.link/lex.pptoken">lex.pptoken</a>]</td> <td>CD7</td> <td>Undefined behavior when lexing unmatched quotes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2575"> <td><a href="https://cplusplus.github.io/CWG/issues/2575.html">2575</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>open</td> <td>Undefined behavior when macro-replacing "defined" operator</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2576"> <td><a href="https://cplusplus.github.io/CWG/issues/2576.html">2576</a></td> + <td>[<a href="https://wg21.link/cpp.include">cpp.include</a>]</td> <td>open</td> <td>Undefined behavior with macro-expanded <TT>#include</TT> directives</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2577"> <td><a href="https://cplusplus.github.io/CWG/issues/2577.html">2577</a></td> + <td>[<a href="https://wg21.link/cpp.replace.general">cpp.replace.general</a>]</td> <td>open</td> <td>Undefined behavior for preprocessing directives in macro arguments</td> <td align="center">Not resolved</td> </tr> <tr id="2578"> <td><a href="https://cplusplus.github.io/CWG/issues/2578.html">2578</a></td> + <td>[<a href="https://wg21.link/cpp.stringize">cpp.stringize</a>]</td> <td>CD7</td> <td>Undefined behavior when creating an invalid string literal via stringizing</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2579"> <td><a href="https://cplusplus.github.io/CWG/issues/2579.html">2579</a></td> + <td>[<a href="https://wg21.link/cpp.concat">cpp.concat</a>]</td> <td>CD7</td> <td>Undefined behavior when token pasting does not create a preprocessing token</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2580"> <td><a href="https://cplusplus.github.io/CWG/issues/2580.html">2580</a></td> + <td>[<a href="https://wg21.link/cpp.line">cpp.line</a>]</td> <td>CD7</td> <td>Undefined behavior with <TT>#line</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2581"> <td><a href="https://cplusplus.github.io/CWG/issues/2581.html">2581</a></td> + <td>[<a href="https://wg21.link/cpp.predefined">cpp.predefined</a>]</td> <td>open</td> <td>Undefined behavior for predefined macros</td> <td align="center">Not resolved</td> </tr> <tr id="2582"> <td><a href="https://cplusplus.github.io/CWG/issues/2582.html">2582</a></td> + <td>[<a href="https://wg21.link/class.member.lookup">class.member.lookup</a>]</td> <td>CD6</td> <td>Differing member lookup from nested classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2583"> <td><a href="https://cplusplus.github.io/CWG/issues/2583.html">2583</a></td> + <td>[<a href="https://wg21.link/class.mem.general">class.mem.general</a>]</td> <td>C++23</td> <td>Common initial sequence should consider over-alignment</td> <td class="full" align="center">Clang 19</td> </tr> <tr class="open" id="2584"> <td><a href="https://cplusplus.github.io/CWG/issues/2584.html">2584</a></td> + <td>[<a href="https://wg21.link/temp.over.link">temp.over.link</a>]</td> <td>open</td> <td>Equivalent types in function template declarations</td> <td align="center">Not resolved</td> </tr> <tr id="2585"> <td><a href="https://cplusplus.github.io/CWG/issues/2585.html">2585</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.coroutine">dcl.fct.def.coroutine</a>]</td> <td>CD6</td> <td>Name lookup for coroutine allocation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2586"> <td><a href="https://cplusplus.github.io/CWG/issues/2586.html">2586</a></td> + <td>[<a href="https://wg21.link/class.compare.default">class.compare.default</a>]</td> <td>CD6</td> <td>Explicit object parameter for assignment and comparison</td> <td class="full" align="center">Clang 20</td> </tr> <tr class="open" id="2587"> <td><a href="https://cplusplus.github.io/CWG/issues/2587.html">2587</a></td> + <td>[<a href="https://wg21.link/intro.races">intro.races</a>]</td> <td>review</td> <td>Visible side effects and initial value of an object</td> <td align="center">Not resolved</td> </tr> <tr id="2588"> <td><a href="https://cplusplus.github.io/CWG/issues/2588.html">2588</a></td> + <td>[<a href="https://wg21.link/class.friend">class.friend</a>]</td> <td>CD7</td> <td>friend declarations and module linkage</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2589"> <td><a href="https://cplusplus.github.io/CWG/issues/2589.html">2589</a></td> + <td>[<a href="https://wg21.link/temp.constr.atomic">temp.constr.atomic</a>]</td> <td>review</td> <td>Context of access checks during constraint satisfaction checking</td> <td align="center">Not resolved</td> </tr> <tr id="2590"> <td><a href="https://cplusplus.github.io/CWG/issues/2590.html">2590</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>C++23</td> <td>Underlying type should determine size and alignment requirements of an enum</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2591"> <td><a href="https://cplusplus.github.io/CWG/issues/2591.html">2591</a></td> + <td>[<a href="https://wg21.link/class.union.general">class.union.general</a>]</td> <td>CD7</td> <td>Implicit change of active union member for anonymous union in union</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2592"> <td><a href="https://cplusplus.github.io/CWG/issues/2592.html">2592</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>open</td> <td>Missing definition for placement allocation/deallocation function</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2593"> <td><a href="https://cplusplus.github.io/CWG/issues/2593.html">2593</a></td> + <td>[<a href="https://wg21.link/expr.mptr.oper">expr.mptr.oper</a>]</td> <td>review</td> <td>Insufficient base class restriction for pointer-to-member expression</td> <td align="center">Not resolved</td> </tr> <tr id="2594"> <td><a href="https://cplusplus.github.io/CWG/issues/2594.html">2594</a></td> + <td>[<a href="https://wg21.link/basic.start.main">basic.start.main</a>]</td> <td>CD6</td> <td>Disallowing a global function template <TT>main</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2595"> <td><a href="https://cplusplus.github.io/CWG/issues/2595.html">2595</a></td> + <td>[<a href="https://wg21.link/special">special</a>]</td> <td>CD7</td> <td>"More constrained" for eligible special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2596"> <td><a href="https://cplusplus.github.io/CWG/issues/2596.html">2596</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>drafting</td> <td>Instantiation of constrained non-template friends</td> <td align="center">Not resolved</td> </tr> <tr id="2597"> <td><a href="https://cplusplus.github.io/CWG/issues/2597.html">2597</a></td> + <td>[<a href="https://wg21.link/module.unit">module.unit</a>]</td> <td>CD6</td> <td>Replaceable allocation and deallocation functions in the global module</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2598"> <td><a href="https://cplusplus.github.io/CWG/issues/2598.html">2598</a></td> + <td>[<a href="https://wg21.link/basic.types.general">basic.types.general</a>]</td> <td>C++23</td> <td>Unions should not require a non-static data member of literal type</td> <td class="full" align="center">Clang 18</td> </tr> <tr id="2599"> <td><a href="https://cplusplus.github.io/CWG/issues/2599.html">2599</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>C++23</td> <td>What does initializing a parameter include?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2600"> <td><a href="https://cplusplus.github.io/CWG/issues/2600.html">2600</a></td> + <td>[<a href="https://wg21.link/temp.dep.expr">temp.dep.expr</a>]</td> <td>CD7</td> <td>Type dependency of placeholder types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2601"> <td><a href="https://cplusplus.github.io/CWG/issues/2601.html">2601</a></td> + <td>[<a href="https://wg21.link/except.ctor">except.ctor</a>]</td> <td>C++23</td> <td>Tracking of created and destroyed subobjects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2602"> <td><a href="https://cplusplus.github.io/CWG/issues/2602.html">2602</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>C++23</td> <td>consteval defaulted functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2603"> <td><a href="https://cplusplus.github.io/CWG/issues/2603.html">2603</a></td> + <td>[<a href="https://wg21.link/temp.over.link">temp.over.link</a>]</td> <td>C++23</td> <td>Holistic functional equivalence for function templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2604"> <td><a href="https://cplusplus.github.io/CWG/issues/2604.html">2604</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>C++23</td> <td>Attributes for an explicit specialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2605"> <td><a href="https://cplusplus.github.io/CWG/issues/2605.html">2605</a></td> + <td>[<a href="https://wg21.link/class.prop">class.prop</a>]</td> <td>C++23</td> <td>Implicit-lifetime aggregates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2606"> <td><a href="https://cplusplus.github.io/CWG/issues/2606.html">2606</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD6</td> <td><TT>static_cast</TT> from "pointer to void" does not handle similar types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2607"> <td><a href="https://cplusplus.github.io/CWG/issues/2607.html">2607</a></td> + <td>[<a href="https://wg21.link/module.interface">module.interface</a>]</td> <td>drafting</td> <td>Visibility of enumerator names</td> <td align="center">Not resolved</td> </tr> <tr id="2608"> <td><a href="https://cplusplus.github.io/CWG/issues/2608.html">2608</a></td> + <td>[<a href="https://wg21.link/temp.arg.explicit">temp.arg.explicit</a>]</td> <td>CD6</td> <td>Omitting an empty template argument list</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2609"> <td><a href="https://cplusplus.github.io/CWG/issues/2609.html">2609</a></td> + <td>[<a href="https://wg21.link/expr.sizeof">expr.sizeof</a>]</td> <td>open</td> <td>Padding in class types</td> <td align="center">Not resolved</td> </tr> <tr id="2610"> <td><a href="https://cplusplus.github.io/CWG/issues/2610.html">2610</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>C++23</td> <td>Indirect private base classes in aggregates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2611"> <td><a href="https://cplusplus.github.io/CWG/issues/2611.html">2611</a></td> + <td>[<a href="https://wg21.link/temp.variadic">temp.variadic</a>]</td> <td>C++23</td> <td>Missing parentheses in expansion of fold-expression could cause syntactic reinterpretation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2612"> <td><a href="https://cplusplus.github.io/CWG/issues/2612.html">2612</a></td> + <td>[<a href="https://wg21.link/dcl.init.general">dcl.init.general</a>]</td> <td>C++23</td> <td>Incorrect comment in example</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2613"> <td><a href="https://cplusplus.github.io/CWG/issues/2613.html">2613</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.coroutine">dcl.fct.def.coroutine</a>]</td> <td>C++23</td> <td>Incomplete definition of resumer</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2614"> <td><a href="https://cplusplus.github.io/CWG/issues/2614.html">2614</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>C++23</td> <td>Unspecified results for class member access</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2615"> <td><a href="https://cplusplus.github.io/CWG/issues/2615.html">2615</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>C++23</td> <td>Missing <TT>__has_cpp_attribute(assume)</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2616"> <td><a href="https://cplusplus.github.io/CWG/issues/2616.html">2616</a></td> + <td>[<a href="https://wg21.link/stmt">stmt</a>]</td> <td>C++23</td> <td>Imprecise restrictions on <TT>break</TT> and <TT>continue</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2617"> <td><a href="https://cplusplus.github.io/CWG/issues/2617.html">2617</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>review</td> <td>Default template arguments for template members of non-template classes</td> <td align="center">Not resolved</td> </tr> <tr id="2618"> <td><a href="https://cplusplus.github.io/CWG/issues/2618.html">2618</a></td> + <td>[<a href="https://wg21.link/temp.deduct.general">temp.deduct.general</a>]</td> <td>C++23</td> <td>Substitution during deduction should exclude exception specifications</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2619"> <td><a href="https://cplusplus.github.io/CWG/issues/2619.html">2619</a></td> + <td>[<a href="https://wg21.link/dcl.init.aggr">dcl.init.aggr</a>]</td> <td>C++23</td> <td>Kind of initialization for a <I>designated-initializer-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2620"> <td><a href="https://cplusplus.github.io/CWG/issues/2620.html">2620</a></td> + <td>[<a href="https://wg21.link/dcl.ambig.res">dcl.ambig.res</a>]</td> <td>C++23</td> <td>Nonsensical disambiguation rule</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2621"> <td><a href="https://cplusplus.github.io/CWG/issues/2621.html">2621</a></td> + <td>[<a href="https://wg21.link/enum.udecl">enum.udecl</a>]</td> <td>C++23</td> <td>Kind of lookup for <TT>using enum</TT> declarations</td> <td class="full-superseded" align="center">Superseded by <a href="#2877">2877</a></td> </tr> <tr id="2622"> <td><a href="https://cplusplus.github.io/CWG/issues/2622.html">2622</a></td> + <td>[<a href="https://wg21.link/implimits">implimits</a>]</td> <td>C++23</td> <td>Compounding types from function and pointer-to-member types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2623"> <td><a href="https://cplusplus.github.io/CWG/issues/2623.html">2623</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>drafting</td> <td>Invoking destroying <TT>operator delete</TT> for constructor failure</td> <td align="center">Not resolved</td> </tr> <tr id="2624"> <td><a href="https://cplusplus.github.io/CWG/issues/2624.html">2624</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>C++23</td> <td>Array delete expression with no array cookie</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2625"> <td><a href="https://cplusplus.github.io/CWG/issues/2625.html">2625</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>C++23</td> <td>Deletion of pointer to out-of-lifetime object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2626"> <td><a href="https://cplusplus.github.io/CWG/issues/2626.html">2626</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>C++23</td> <td>Rephrase ones' complement using base-2 representation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2627"> <td><a href="https://cplusplus.github.io/CWG/issues/2627.html">2627</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>C++23</td> <td>Bit-fields and narrowing conversions</td> <td class="full" align="center">Clang 20</td> </tr> <tr id="2628"> <td><a href="https://cplusplus.github.io/CWG/issues/2628.html">2628</a></td> + <td>[<a href="https://wg21.link/over.match.class.deduct">over.match.class.deduct</a>]</td> <td>CD7</td> <td>Implicit deduction guides should propagate constraints</td> <td class="full" align="center">Clang 20</td> </tr> <tr id="2629"> <td><a href="https://cplusplus.github.io/CWG/issues/2629.html">2629</a></td> + <td>[<a href="https://wg21.link/stmt.switch">stmt.switch</a>]</td> <td>C++23</td> <td>Variables of floating-point type as <TT>switch</TT> conditions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2630"> <td><a href="https://cplusplus.github.io/CWG/issues/2630.html">2630</a></td> + <td>[<a href="https://wg21.link/class.mem.general">class.mem.general</a>]</td> <td>C++23</td> <td>Syntactic specification of class completeness</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="2631"> <td><a href="https://cplusplus.github.io/CWG/issues/2631.html">2631</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++23</td> <td>Immediate function evaluations in default arguments</td> <td class="full" align="center">Clang 16</td> </tr> <tr class="open" id="2632"> <td><a href="https://cplusplus.github.io/CWG/issues/2632.html">2632</a></td> + <td>[<a href="https://wg21.link/intro.defs">intro.defs</a>]</td> <td>drafting</td> <td>'user-declared' is not defined</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2633"> <td><a href="https://cplusplus.github.io/CWG/issues/2633.html">2633</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>typeid of constexpr-unknown dynamic type</td> <td align="center">Not resolved</td> </tr> <tr id="2634"> <td><a href="https://cplusplus.github.io/CWG/issues/2634.html">2634</a></td> + <td>[<a href="https://wg21.link/dcl.type.elab">dcl.type.elab</a>]</td> <td>CD7</td> <td>Avoid circularity in specification of scope for friend class declarations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2635"> <td><a href="https://cplusplus.github.io/CWG/issues/2635.html">2635</a></td> + <td>[<a href="https://wg21.link/dcl.pre">dcl.pre</a>]</td> <td>C++23</td> <td>Constrained structured bindings</td> <td class="full" align="center">Clang 16</td> </tr> <tr id="2636"> <td><a href="https://cplusplus.github.io/CWG/issues/2636.html">2636</a></td> + <td>[<a href="https://wg21.link/ub">ub</a>]</td> <td>C++23</td> <td>Update Annex E based on Unicode 15.0 UAX #31</td> <td class="na" align="center">N/A</td> </tr> <tr id="2637"> <td><a href="https://cplusplus.github.io/CWG/issues/2637.html">2637</a></td> + <td>[<a href="https://wg21.link/class.pre">class.pre</a>]</td> <td>CD7</td> <td>Injected-class-name as a <I>simple-template-id</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2638"> <td><a href="https://cplusplus.github.io/CWG/issues/2638.html">2638</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD7</td> <td>Improve the example for initializing by initializer list</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2639"> <td><a href="https://cplusplus.github.io/CWG/issues/2639.html">2639</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>C++23</td> <td>new-lines after phase 1</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2640"> <td><a href="https://cplusplus.github.io/CWG/issues/2640.html">2640</a></td> + <td>[<a href="https://wg21.link/lex.charset">lex.charset</a>]</td> <td>C++23</td> <td>Allow more characters in an n-char sequence</td> <td class="full" align="center">Clang 16</td> </tr> <tr id="2641"> <td><a href="https://cplusplus.github.io/CWG/issues/2641.html">2641</a></td> + <td>[<a href="https://wg21.link/lex.literal">lex.literal</a>]</td> <td>C++23</td> <td>Redundant specification of value category of literals</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2642"> <td><a href="https://cplusplus.github.io/CWG/issues/2642.html">2642</a></td> + <td>[<a href="https://wg21.link/class.member.lookup">class.member.lookup</a>]</td> <td>C++23</td> <td>Inconsistent use of T and C</td> <td class="na" align="center">N/A</td> </tr> <tr id="2643"> <td><a href="https://cplusplus.github.io/CWG/issues/2643.html">2643</a></td> + <td>[<a href="https://wg21.link/basic.types.general">basic.types.general</a>]</td> <td>C++23</td> <td>Completing a pointer to array of unknown bound</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2644"> <td><a href="https://cplusplus.github.io/CWG/issues/2644.html">2644</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>C++23</td> <td>Incorrect comment in example</td> <td class="full" align="center">Clang 8</td> </tr> <tr id="2645"> <td><a href="https://cplusplus.github.io/CWG/issues/2645.html">2645</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>C++23</td> <td>Unused term "default argument promotions"</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2646"> <td><a href="https://cplusplus.github.io/CWG/issues/2646.html">2646</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>C++23</td> <td>Defaulted special member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2647"> <td><a href="https://cplusplus.github.io/CWG/issues/2647.html">2647</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++23</td> <td>Fix for "needed for constant evaluation"</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2648"> <td><a href="https://cplusplus.github.io/CWG/issues/2648.html">2648</a></td> + <td>[<a href="https://wg21.link/over.call">over.call</a>]</td> <td>C++23</td> <td>Correspondence of surrogate call function and conversion function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2649"> <td><a href="https://cplusplus.github.io/CWG/issues/2649.html">2649</a></td> + <td>[<a href="https://wg21.link/over.call.object">over.call.object</a>]</td> <td>C++23</td> <td>Incorrect note about implicit conversion sequence</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2650"> <td><a href="https://cplusplus.github.io/CWG/issues/2650.html">2650</a></td> + <td>[<a href="https://wg21.link/temp.deduct.general">temp.deduct.general</a>]</td> <td>C++23</td> <td>Incorrect example for ill-formed non-type template arguments</td> <td class="full" align="center">Clang 17</td> </tr> <tr id="2651"> <td><a href="https://cplusplus.github.io/CWG/issues/2651.html">2651</a></td> + <td>[<a href="https://wg21.link/temp.deduct.conv">temp.deduct.conv</a>]</td> <td>C++23</td> <td>Conversion function templates and "noexcept"</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2652"> <td><a href="https://cplusplus.github.io/CWG/issues/2652.html">2652</a></td> + <td>[<a href="https://wg21.link/cpp.predefined">cpp.predefined</a>]</td> <td>C++23</td> <td>Overbroad definition of <TT>__STDCPP_BFLOAT16_T__</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2653"> <td><a href="https://cplusplus.github.io/CWG/issues/2653.html">2653</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>C++23</td> <td>Can an explicit object parameter have a default argument?</td> <td class="full" align="center">Clang 18</td> </tr> <tr id="2654"> <td><a href="https://cplusplus.github.io/CWG/issues/2654.html">2654</a></td> + <td>[<a href="https://wg21.link/expr.assign">expr.assign</a>]</td> <td>C++23</td> <td>Un-deprecation of compound volatile assignments</td> <td class="full" align="center">Clang 16</td> </tr> <tr id="2655"> <td><a href="https://cplusplus.github.io/CWG/issues/2655.html">2655</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>NAD</td> <td>Instantiation of default arguments in <I>lambda-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2656"> <td><a href="https://cplusplus.github.io/CWG/issues/2656.html">2656</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>drafting</td> <td>Converting consteval lambda to function pointer in non-immediate context</td> <td align="center">Not resolved</td> </tr> <tr id="2657"> <td><a href="https://cplusplus.github.io/CWG/issues/2657.html">2657</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD7</td> <td>Cv-qualification adjustment when binding reference to temporary</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2658"> <td><a href="https://cplusplus.github.io/CWG/issues/2658.html">2658</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>C++23</td> <td>Trivial copying of unions in core constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2659"> <td><a href="https://cplusplus.github.io/CWG/issues/2659.html">2659</a></td> + <td>[<a href="https://wg21.link/cpp.predefined">cpp.predefined</a>]</td> <td>C++23</td> <td>Missing feature-test macro for lifetime extension in range-for loop</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2660"> <td><a href="https://cplusplus.github.io/CWG/issues/2660.html">2660</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>open</td> <td>Confusing term "this parameter"</td> <td align="center">Not resolved</td> </tr> <tr id="2661"> <td><a href="https://cplusplus.github.io/CWG/issues/2661.html">2661</a></td> + <td>[<a href="https://wg21.link/class.mem.general">class.mem.general</a>]</td> <td>CD7</td> <td>Missing disambiguation rule for <I>pure-specifier</I> vs. <I>brace-or-equal-initializer</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2662"> <td><a href="https://cplusplus.github.io/CWG/issues/2662.html">2662</a></td> + <td>[<a href="https://wg21.link/class.access.general">class.access.general</a>]</td> <td>C++23</td> <td>Example for member access control vs. overload resolution</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2663"> <td><a href="https://cplusplus.github.io/CWG/issues/2663.html">2663</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>CD7</td> <td>Example for member redeclarations with <I>using-declaration</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2664"> <td><a href="https://cplusplus.github.io/CWG/issues/2664.html">2664</a></td> + <td>[<a href="https://wg21.link/over.match.class.deduct">over.match.class.deduct</a>]</td> <td>C++23</td> <td>Deduction failure in CTAD for alias templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2665"> <td><a href="https://cplusplus.github.io/CWG/issues/2665.html">2665</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>NAD</td> <td>Replacing a subobject with a complete object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2666"> <td><a href="https://cplusplus.github.io/CWG/issues/2666.html">2666</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>open</td> <td>Lifetime extension through <TT>static_cast</TT></td> <td align="center">Not resolved</td> </tr> <tr id="2667"> <td><a href="https://cplusplus.github.io/CWG/issues/2667.html">2667</a></td> + <td>[<a href="https://wg21.link/cpp.import">cpp.import</a>]</td> <td>C++23</td> <td>Named module imports do not import macros</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2668"> <td><a href="https://cplusplus.github.io/CWG/issues/2668.html">2668</a></td> + <td>[<a href="https://wg21.link/expr.await">expr.await</a>]</td> <td>CD7</td> <td><TT>co_await</TT> in a <I>lambda-expression</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2669"> <td><a href="https://cplusplus.github.io/CWG/issues/2669.html">2669</a></td> + <td>[<a href="https://wg21.link/class.base.init">class.base.init</a>]</td> <td>open</td> <td>Lifetime extension for aggregate initialization</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2670"> <td><a href="https://cplusplus.github.io/CWG/issues/2670.html">2670</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>open</td> <td>Programs and translation units</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2671"> <td><a href="https://cplusplus.github.io/CWG/issues/2671.html">2671</a></td> + <td>[<a href="https://wg21.link/dcl.meaning.general">dcl.meaning.general</a>]</td> <td>open</td> <td>friend named by a <I>template-id</I></td> <td align="center">Not resolved</td> </tr> <tr id="2672"> <td><a href="https://cplusplus.github.io/CWG/issues/2672.html">2672</a></td> + <td>[<a href="https://wg21.link/temp.deduct.general">temp.deduct.general</a>]</td> <td>CD7</td> <td>Lambda body SFINAE is still required, contrary to intent and note</td> <td class="full" align="center">Clang 18</td> </tr> <tr id="2673"> <td><a href="https://cplusplus.github.io/CWG/issues/2673.html">2673</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>C++23</td> <td>User-declared spaceship vs. built-in operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2674"> <td><a href="https://cplusplus.github.io/CWG/issues/2674.html">2674</a></td> + <td>[<a href="https://wg21.link/class.ctor.general">class.ctor.general</a>]</td> <td>C++23</td> <td>Prohibit explicit object parameters for constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2675"> <td><a href="https://cplusplus.github.io/CWG/issues/2675.html">2675</a></td> + <td>[<a href="https://wg21.link/class.union.general">class.union.general</a>]</td> <td>open</td> <td><TT>start_lifetime_as</TT>, placement-new, and active union members</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2676"> <td><a href="https://cplusplus.github.io/CWG/issues/2676.html">2676</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>open</td> <td>Replacing a complete object having base subobjects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2677"> <td><a href="https://cplusplus.github.io/CWG/issues/2677.html">2677</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>review</td> <td>Replacing union subobjects</td> <td align="center">Not resolved</td> </tr> <tr id="2678"> <td><a href="https://cplusplus.github.io/CWG/issues/2678.html">2678</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>C++23</td> <td><TT>std::source_location::current</TT> is unimplementable</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2679"> <td><a href="https://cplusplus.github.io/CWG/issues/2679.html">2679</a></td> + <td>[<a href="https://wg21.link/over.best.ics.general">over.best.ics.general</a>]</td> <td>open</td> <td>Implicit conversion sequence with a null pointer constant</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2680"> <td><a href="https://cplusplus.github.io/CWG/issues/2680.html">2680</a></td> + <td>[<a href="https://wg21.link/over.match.class.deduct">over.match.class.deduct</a>]</td> <td>open</td> <td>Class template argument deduction for aggregates with designated initializers</td> <td align="center">Not resolved</td> </tr> <tr id="2681"> <td><a href="https://cplusplus.github.io/CWG/issues/2681.html">2681</a></td> + <td>[<a href="https://wg21.link/over.match.class.deduct">over.match.class.deduct</a>]</td> <td>C++23</td> <td>Deducing member array type from string literal</td> <td class="full" align="center">Clang 17</td> </tr> <tr id="2682"> <td><a href="https://cplusplus.github.io/CWG/issues/2682.html">2682</a></td> + <td>[<a href="https://wg21.link/temp.pre">temp.pre</a>]</td> <td>C++23</td> <td>Templated function vs. function template</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2683"> <td><a href="https://cplusplus.github.io/CWG/issues/2683.html">2683</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>CD7</td> <td>Default arguments for member functions of templated nested classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2684"> <td><a href="https://cplusplus.github.io/CWG/issues/2684.html">2684</a></td> + <td>[<a href="https://wg21.link/basic.start.dynamic">basic.start.dynamic</a>]</td> <td>open</td> <td>thread_local dynamic initialization</td> <td align="center">Not resolved</td> </tr> <tr id="2685"> <td><a href="https://cplusplus.github.io/CWG/issues/2685.html">2685</a></td> + <td>[<a href="https://wg21.link/over.match.class.deduct">over.match.class.deduct</a>]</td> <td>C++23</td> <td>Aggregate CTAD, string, and brace elision</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2686"> <td><a href="https://cplusplus.github.io/CWG/issues/2686.html">2686</a></td> + <td>[<a href="https://wg21.link/temp.constr.constr">temp.constr.constr</a>]</td> <td>open</td> <td>Pack expansion into a non-pack parameter of a concept</td> <td align="center">Not resolved</td> </tr> <tr id="2687"> <td><a href="https://cplusplus.github.io/CWG/issues/2687.html">2687</a></td> + <td>[<a href="https://wg21.link/over.match.call.general">over.match.call.general</a>]</td> <td>C++23</td> <td>Calling an explicit object member function via an address-of-overload-set</td> <td class="full" align="center">Clang 18</td> </tr> <tr class="open" id="2688"> <td><a href="https://cplusplus.github.io/CWG/issues/2688.html">2688</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>open</td> <td>Calling explicit object member functions</td> <td align="center">Not resolved</td> </tr> <tr id="2689"> <td><a href="https://cplusplus.github.io/CWG/issues/2689.html">2689</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>CD7</td> <td>Are cv-qualified <TT>std::nullptr_t</TT> fundamental types?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2690"> <td><a href="https://cplusplus.github.io/CWG/issues/2690.html">2690</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>C++23</td> <td>Semantics of defaulted move assignment operator for unions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2691"> <td><a href="https://cplusplus.github.io/CWG/issues/2691.html">2691</a></td> + <td>[<a href="https://wg21.link/lex.ccon">lex.ccon</a>]</td> <td>C++23</td> <td><I>hexadecimal-escape-sequence</I> is too greedy</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2692"> <td><a href="https://cplusplus.github.io/CWG/issues/2692.html">2692</a></td> + <td>[<a href="https://wg21.link/over.match.call.general">over.match.call.general</a>]</td> <td>C++23</td> <td>Static and explicit object member functions with the same parameter-type-lists</td> <td class="full" align="center">Clang 19</td> </tr> <tr class="open" id="2693"> <td><a href="https://cplusplus.github.io/CWG/issues/2693.html">2693</a></td> + <td>[<a href="https://wg21.link/cpp.line">cpp.line</a>]</td> <td>open</td> <td>Escape sequences for the <I>string-literal</I> of <TT>#line</TT></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2694"> <td><a href="https://cplusplus.github.io/CWG/issues/2694.html">2694</a></td> + <td>[<a href="https://wg21.link/cpp.pragma.op">cpp.pragma.op</a>]</td> <td>open</td> <td><I>string-literal</I>s of the <TT>_Pragma</TT> operator</td> <td align="center">Not resolved</td> </tr> <tr id="2695"> <td><a href="https://cplusplus.github.io/CWG/issues/2695.html">2695</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>C++23</td> <td>Semantic ignorability of attributes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2696"> <td><a href="https://cplusplus.github.io/CWG/issues/2696.html">2696</a></td> + <td>[<a href="https://wg21.link/expr.rel">expr.rel</a>]</td> <td>dup</td> <td>Relational comparisons of pointers to <TT>void</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2697"> <td><a href="https://cplusplus.github.io/CWG/issues/2697.html">2697</a></td> + <td>[<a href="https://wg21.link/temp.deduct.guide">temp.deduct.guide</a>]</td> <td>CD7</td> <td>Deduction guides using abbreviated function syntax</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2698"> <td><a href="https://cplusplus.github.io/CWG/issues/2698.html">2698</a></td> + <td>[<a href="https://wg21.link/lex.icon">lex.icon</a>]</td> <td>CD7</td> <td>Using extended integer types with <TT>z</TT> suffix</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2699"> <td><a href="https://cplusplus.github.io/CWG/issues/2699.html">2699</a></td> + <td>[<a href="https://wg21.link/expr.throw">expr.throw</a>]</td> <td>CD7</td> <td>Inconsistency of <I>throw-expression</I> specification</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2700"> <td><a href="https://cplusplus.github.io/CWG/issues/2700.html">2700</a></td> + <td>[<a href="https://wg21.link/intro.compliance.general">intro.compliance.general</a>]</td> <td>CD7</td> <td><TT>#error</TT> disallows existing implementation practice</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2701"> <td><a href="https://cplusplus.github.io/CWG/issues/2701.html">2701</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>open</td> <td>Default arguments in multiple scopes / inheritance of array bounds in the same scope</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2702"> <td><a href="https://cplusplus.github.io/CWG/issues/2702.html">2702</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Constant destruction of reference members</td> <td align="center">Not resolved</td> </tr> <tr id="2703"> <td><a href="https://cplusplus.github.io/CWG/issues/2703.html">2703</a></td> + <td>[<a href="https://wg21.link/class.spaceship">class.spaceship</a>]</td> <td>CD7</td> <td>Three-way comparison requiring strong ordering for floating-point types, take 2</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2704"> <td><a href="https://cplusplus.github.io/CWG/issues/2704.html">2704</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>open</td> <td>Clarify meaning of "bind directly"</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2705"> <td><a href="https://cplusplus.github.io/CWG/issues/2705.html">2705</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>open</td> <td>Accessing ambiguous subobjects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2706"> <td><a href="https://cplusplus.github.io/CWG/issues/2706.html">2706</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>open</td> <td>Repeated structured binding declarations</td> <td align="center">Not resolved</td> </tr> <tr id="2707"> <td><a href="https://cplusplus.github.io/CWG/issues/2707.html">2707</a></td> + <td>[<a href="https://wg21.link/temp.deduct.guide">temp.deduct.guide</a>]</td> <td>CD7</td> <td>Deduction guides cannot have a trailing <I>requires-clause</I></td> <td class="full" align="center">Clang 20</td> </tr> <tr id="2708"> <td><a href="https://cplusplus.github.io/CWG/issues/2708.html">2708</a></td> + <td>[<a href="https://wg21.link/dcl.init.general">dcl.init.general</a>]</td> <td>CD7</td> <td>Parenthesized initialization of arrays</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2709"> <td><a href="https://cplusplus.github.io/CWG/issues/2709.html">2709</a></td> + <td>[<a href="https://wg21.link/dcl.init.general">dcl.init.general</a>]</td> <td>NAD</td> <td>Parenthesized initialization of reference-to-aggregate</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2710"> <td><a href="https://cplusplus.github.io/CWG/issues/2710.html">2710</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>Loops in constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2711"> <td><a href="https://cplusplus.github.io/CWG/issues/2711.html">2711</a></td> + <td>[<a href="https://wg21.link/expr.throw">expr.throw</a>]</td> <td>CD7</td> <td>Source for copy-initializing the exception object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2712"> <td><a href="https://cplusplus.github.io/CWG/issues/2712.html">2712</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>CD7</td> <td>Simplify restrictions on built-in assignment operator candidates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2713"> <td><a href="https://cplusplus.github.io/CWG/issues/2713.html">2713</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD7</td> <td>Initialization of reference-to-aggregate from designated initializer list</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2714"> <td><a href="https://cplusplus.github.io/CWG/issues/2714.html">2714</a></td> + <td>[<a href="https://wg21.link/over.match.class.deduct">over.match.class.deduct</a>]</td> <td>CD7</td> <td>Implicit deduction guides omit properties from the parameter-declaration-clause of a constructor</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2715"> <td><a href="https://cplusplus.github.io/CWG/issues/2715.html">2715</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>CD7</td> <td>"calling function" for parameter initialization may not exist</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2716"> <td><a href="https://cplusplus.github.io/CWG/issues/2716.html">2716</a></td> + <td>[<a href="https://wg21.link/class.conv.fct">class.conv.fct</a>]</td> <td>CD7</td> <td>Rule about self-or-base conversion is normatively redundant</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2717"> <td><a href="https://cplusplus.github.io/CWG/issues/2717.html">2717</a></td> + <td>[<a href="https://wg21.link/temp.variadic">temp.variadic</a>]</td> <td>CD7</td> <td>Pack expansion for <I>alignment-specifier</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2718"> <td><a href="https://cplusplus.github.io/CWG/issues/2718.html">2718</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD7</td> <td>Type completeness for derived-to-base conversions</td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="2719"> <td><a href="https://cplusplus.github.io/CWG/issues/2719.html">2719</a></td> + <td>[<a href="https://wg21.link/basic.align">basic.align</a>]</td> <td>CD7</td> <td>Creating objects in misaligned storage</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2720"> <td><a href="https://cplusplus.github.io/CWG/issues/2720.html">2720</a></td> + <td>[<a href="https://wg21.link/temp.res.general">temp.res.general</a>]</td> <td>CD7</td> <td>Template validity rules for templated entities and alias templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2721"> <td><a href="https://cplusplus.github.io/CWG/issues/2721.html">2721</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>CD7</td> <td>When exactly is storage reused?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2722"> <td><a href="https://cplusplus.github.io/CWG/issues/2722.html">2722</a></td> + <td>[<a href="https://wg21.link/expr.unary.noexcept">expr.unary.noexcept</a>]</td> <td>CD7</td> <td>Temporary materialization conversion for <TT>noexcept</TT> operator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2723"> <td><a href="https://cplusplus.github.io/CWG/issues/2723.html">2723</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>CD7</td> <td>Range of representable values for floating-point types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2724"> <td><a href="https://cplusplus.github.io/CWG/issues/2724.html">2724</a></td> + <td>[<a href="https://wg21.link/expr.shift">expr.shift</a>]</td> <td>CD7</td> <td>Clarify rounding for arithmetic right shift</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2725"> <td><a href="https://cplusplus.github.io/CWG/issues/2725.html">2725</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>CD7</td> <td>Overload resolution for non-call of class member access</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2726"> <td><a href="https://cplusplus.github.io/CWG/issues/2726.html">2726</a></td> + <td>[<a href="https://wg21.link/lex.digraph">lex.digraph</a>]</td> <td>review</td> <td>Alternative tokens appearing as <I>attribute-token</I>s</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2727"> <td><a href="https://cplusplus.github.io/CWG/issues/2727.html">2727</a></td> + <td>[<a href="https://wg21.link/module.import">module.import</a>]</td> <td>open</td> <td>Importing header units synthesized from source files</td> <td align="center">Not resolved</td> </tr> <tr id="2728"> <td><a href="https://cplusplus.github.io/CWG/issues/2728.html">2728</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>CD7</td> <td>Evaluation of conversions in a <I>delete-expression</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2729"> <td><a href="https://cplusplus.github.io/CWG/issues/2729.html">2729</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>CD7</td> <td>Meaning of <I>new-type-id</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2730"> <td><a href="https://cplusplus.github.io/CWG/issues/2730.html">2730</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>open</td> <td>Comparison templates on enumeration types</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2731"> <td><a href="https://cplusplus.github.io/CWG/issues/2731.html">2731</a></td> + <td>[<a href="https://wg21.link/over.ics.user">over.ics.user</a>]</td> <td>open</td> <td>List-initialization sequence with a user-defined conversion</td> <td align="center">Not resolved</td> </tr> <tr id="2732"> <td><a href="https://cplusplus.github.io/CWG/issues/2732.html">2732</a></td> + <td>[<a href="https://wg21.link/module.import">module.import</a>]</td> <td>CD7</td> <td>Can importable headers react to preprocessor state from point of import?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2733"> <td><a href="https://cplusplus.github.io/CWG/issues/2733.html">2733</a></td> + <td>[<a href="https://wg21.link/dcl.attr.unused">dcl.attr.unused</a>]</td> <td>CD7</td> <td>Applying <TT>[[maybe_unused]]</TT> to a label</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2734"> <td><a href="https://cplusplus.github.io/CWG/issues/2734.html">2734</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Immediate forward-declared function templates</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2735"> <td><a href="https://cplusplus.github.io/CWG/issues/2735.html">2735</a></td> + <td>[<a href="https://wg21.link/over.match.best">over.match.best</a>]</td> <td>open</td> <td>List-initialization and conversions in overload resolution</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2736"> <td><a href="https://cplusplus.github.io/CWG/issues/2736.html">2736</a></td> + <td>[<a href="https://wg21.link/class.prop">class.prop</a>]</td> <td>open</td> <td>Standard layout class with empty base class also in first member</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2737"> <td><a href="https://cplusplus.github.io/CWG/issues/2737.html">2737</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.capture">expr.prim.lambda.capture</a>]</td> <td>review</td> <td>Temporary lifetime extension for reference init-captures</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2738"> <td><a href="https://cplusplus.github.io/CWG/issues/2738.html">2738</a></td> + <td>[<a href="https://wg21.link/expr.prim.id.unqual">expr.prim.id.unqual</a>]</td> <td>review</td> <td>"denotes a destructor" is missing specification</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2739"> <td><a href="https://cplusplus.github.io/CWG/issues/2739.html">2739</a></td> + <td>[<a href="https://wg21.link/expr.prim.req.nested">expr.prim.req.nested</a>]</td> <td>open</td> <td>Nested requirement not a constant expression</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2740"> <td><a href="https://cplusplus.github.io/CWG/issues/2740.html">2740</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Too many objects have constexpr-unknown type</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2741"> <td><a href="https://cplusplus.github.io/CWG/issues/2741.html">2741</a></td> + <td>[<a href="https://wg21.link/over.ics.list">over.ics.list</a>]</td> <td>open</td> <td>Implicit conversion sequence from empty list to array of unknown bound</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2742"> <td><a href="https://cplusplus.github.io/CWG/issues/2742.html">2742</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>drafting</td> <td>Guaranteed copy elision for brace-initialization from prvalue</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2743"> <td><a href="https://cplusplus.github.io/CWG/issues/2743.html">2743</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>open</td> <td>Copying non-trivial objects nested within a union</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2744"> <td><a href="https://cplusplus.github.io/CWG/issues/2744.html">2744</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>open</td> <td>Multiple objects of the same type at the same address</td> <td align="center">Not resolved</td> </tr> <tr id="2745"> <td><a href="https://cplusplus.github.io/CWG/issues/2745.html">2745</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD7</td> <td>Dependent odr-use in generic lambdas</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2746"> <td><a href="https://cplusplus.github.io/CWG/issues/2746.html">2746</a></td> + <td>[<a href="https://wg21.link/temp.res.general">temp.res.general</a>]</td> <td>CD7</td> <td>Checking of default template arguments</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2747"> <td><a href="https://cplusplus.github.io/CWG/issues/2747.html">2747</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>CD7</td> <td>Cannot depend on an already-deleted splice</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2748"> <td><a href="https://cplusplus.github.io/CWG/issues/2748.html">2748</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>CD7</td> <td>Accessing static data members via null pointer</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2749"> <td><a href="https://cplusplus.github.io/CWG/issues/2749.html">2749</a></td> + <td>[<a href="https://wg21.link/expr.rel">expr.rel</a>]</td> <td>CD7</td> <td>Treatment of "pointer to void" for relational comparisons</td> <td class="full" align="center">Clang 20</td> </tr> <tr id="2750"> <td><a href="https://cplusplus.github.io/CWG/issues/2750.html">2750</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>construct_at without constructor call</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2751"> <td><a href="https://cplusplus.github.io/CWG/issues/2751.html">2751</a></td> + <td>[<a href="https://wg21.link/stmt.dcl">stmt.dcl</a>]</td> <td>NAD</td> <td>Order of destruction for parameters for operator functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2752"> <td><a href="https://cplusplus.github.io/CWG/issues/2752.html">2752</a></td> + <td>[<a href="https://wg21.link/lex.fcon">lex.fcon</a>]</td> <td>open</td> <td>Excess-precision floating-point literals</td> <td align="center">Not resolved</td> </tr> <tr id="2753"> <td><a href="https://cplusplus.github.io/CWG/issues/2753.html">2753</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>CD7</td> <td>Storage reuse for string literal objects and backing arrays</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2754"> <td><a href="https://cplusplus.github.io/CWG/issues/2754.html">2754</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.coroutine">dcl.fct.def.coroutine</a>]</td> <td>CD7</td> <td>Using *this in explicit object member functions that are coroutines</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2755"> <td><a href="https://cplusplus.github.io/CWG/issues/2755.html">2755</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>Incorrect wording applied by P2738R1</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2756"> <td><a href="https://cplusplus.github.io/CWG/issues/2756.html">2756</a></td> + <td>[<a href="https://wg21.link/class.init">class.init</a>]</td> <td>review</td> <td>Completion of initialization by delegating constructor</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2757"> <td><a href="https://cplusplus.github.io/CWG/issues/2757.html">2757</a></td> + <td>[<a href="https://wg21.link/class.cdtor">class.cdtor</a>]</td> <td>review</td> <td>Deleting or deallocating storage of an object during its construction</td> <td align="center">Not resolved</td> </tr> <tr id="2758"> <td><a href="https://cplusplus.github.io/CWG/issues/2758.html">2758</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>CD7</td> <td>What is "access and ambiguity control"?</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2759"> <td><a href="https://cplusplus.github.io/CWG/issues/2759.html">2759</a></td> + <td>[<a href="https://wg21.link/class.mem.general">class.mem.general</a>]</td> <td>CD7</td> <td>[[no_unique_address] and common initial sequence</td> <td class="full" align="center">Clang 19</td> </tr> <tr id="2760"> <td><a href="https://cplusplus.github.io/CWG/issues/2760.html">2760</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>Defaulted constructor that is an immediate function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2761"> <td><a href="https://cplusplus.github.io/CWG/issues/2761.html">2761</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD7</td> <td>Implicitly invoking the deleted destructor of an anonymous union member</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2762"> <td><a href="https://cplusplus.github.io/CWG/issues/2762.html">2762</a></td> + <td>[<a href="https://wg21.link/over.match.funcs.general">over.match.funcs.general</a>]</td> <td>CD7</td> <td>Type of implicit object parameter</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2763"> <td><a href="https://cplusplus.github.io/CWG/issues/2763.html">2763</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>Ignorability of [[noreturn]] during constant evaluation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2764"> <td><a href="https://cplusplus.github.io/CWG/issues/2764.html">2764</a></td> + <td>[<a href="https://wg21.link/basic.scope.scope">basic.scope.scope</a>]</td> <td>CD7</td> <td>Use of placeholders affecting name mangling</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2765"> <td><a href="https://cplusplus.github.io/CWG/issues/2765.html">2765</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>open</td> <td>Address comparisons between potentially non-unique objects during constant evaluation</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2766"> <td><a href="https://cplusplus.github.io/CWG/issues/2766.html">2766</a></td> + <td>[<a href="https://wg21.link/lex.string">lex.string</a>]</td> <td>open</td> - <td>Repeated evaluation of a <I>string-literal</I> may yield different -objects</td> + <td>Repeated evaluation of a <I>string-literal</I> may yield different objects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2767"> <td><a href="https://cplusplus.github.io/CWG/issues/2767.html">2767</a></td> + <td>[<a href="https://wg21.link/class.union.anon">class.union.anon</a>]</td> <td>open</td> <td>Non-defining declarations of anonymous unions</td> <td align="center">Not resolved</td> </tr> <tr id="2768"> <td><a href="https://cplusplus.github.io/CWG/issues/2768.html">2768</a></td> + <td>[<a href="https://wg21.link/expr.assign">expr.assign</a>]</td> <td>CD7</td> <td>Assignment to enumeration variable with a <I>braced-init-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2769"> <td><a href="https://cplusplus.github.io/CWG/issues/2769.html">2769</a></td> + <td>[<a href="https://wg21.link/temp.deduct.general">temp.deduct.general</a>]</td> <td>open</td> <td>Substitution into template parameters and default template arguments should be interleaved</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2770"> <td><a href="https://cplusplus.github.io/CWG/issues/2770.html">2770</a></td> + <td>[<a href="https://wg21.link/temp.deduct.general">temp.deduct.general</a>]</td> <td>open</td> <td>Trailing <I>requires-clause</I> can refer to function parameters before they are substituted into</td> <td align="center"> @@ -16476,462 +19203,539 @@ objects</td> </tr> <tr id="2771"> <td><a href="https://cplusplus.github.io/CWG/issues/2771.html">2771</a></td> + <td>[<a href="https://wg21.link/class.mfct.non.static">class.mfct.non.static</a>]</td> <td>CD7</td> <td>Transformation for <I>unqualified-id</I>s in address operator</td> <td class="full" align="center">Clang 18</td> </tr> <tr id="2772"> <td><a href="https://cplusplus.github.io/CWG/issues/2772.html">2772</a></td> + <td>[<a href="https://wg21.link/diff.cpp03.dcl.dcl">diff.cpp03.dcl.dcl</a>]</td> <td>CD7</td> <td>Missing Annex C entry for linkage effects of <I>linkage-specification</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2773"> <td><a href="https://cplusplus.github.io/CWG/issues/2773.html">2773</a></td> + <td>[<a href="https://wg21.link/class.union.anon">class.union.anon</a>]</td> <td>open</td> <td>Naming anonymous union members as class members</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2774"> <td><a href="https://cplusplus.github.io/CWG/issues/2774.html">2774</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>open</td> <td>Value-dependence of <I>requires-expression</I>s</td> <td align="center">Not resolved</td> </tr> <tr id="2775"> <td><a href="https://cplusplus.github.io/CWG/issues/2775.html">2775</a></td> + <td>[<a href="https://wg21.link/except.throw">except.throw</a>]</td> <td>CD7</td> <td>Unclear argument type for copy of exception object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2776"> <td><a href="https://cplusplus.github.io/CWG/issues/2776.html">2776</a></td> + <td>[<a href="https://wg21.link/intro.compliance.general">intro.compliance.general</a>]</td> <td>open</td> <td>Substitution failure and implementation limits</td> <td align="center">Not resolved</td> </tr> <tr id="2777"> <td><a href="https://cplusplus.github.io/CWG/issues/2777.html">2777</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>CD7</td> <td>Type of <I>id-expression</I> denoting a template parameter object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2778"> <td><a href="https://cplusplus.github.io/CWG/issues/2778.html">2778</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>review</td> <td>Trivial destructor does not imply constant destruction</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2779"> <td><a href="https://cplusplus.github.io/CWG/issues/2779.html">2779</a></td> + <td>[<a href="https://wg21.link/lex.charset">lex.charset</a>]</td> <td>open</td> <td>Restrictions on the ordinary literal encoding</td> <td align="center">Not resolved</td> </tr> <tr id="2780"> <td><a href="https://cplusplus.github.io/CWG/issues/2780.html">2780</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>CD7</td> <td><TT>reinterpret_cast</TT> to reference to function types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2781"> <td><a href="https://cplusplus.github.io/CWG/issues/2781.html">2781</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>open</td> <td>Unclear recursion in the one-definition rule</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2782"> <td><a href="https://cplusplus.github.io/CWG/issues/2782.html">2782</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>open</td> <td>Treatment of closure types in the one-definition rule</td> <td align="center">Not resolved</td> </tr> <tr id="2783"> <td><a href="https://cplusplus.github.io/CWG/issues/2783.html">2783</a></td> + <td>[<a href="https://wg21.link/module.global.frag">module.global.frag</a>]</td> <td>CD7</td> <td>Handling of deduction guides in <I>global-module-fragment</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2784"> <td><a href="https://cplusplus.github.io/CWG/issues/2784.html">2784</a></td> + <td>[<a href="https://wg21.link/support.types.layout">support.types.layout</a>]</td> <td>open</td> <td>Unclear definition of <I>member-designator</I> for <TT>offsetof</TT></td> <td align="center">Not resolved</td> </tr> <tr id="2785"> <td><a href="https://cplusplus.github.io/CWG/issues/2785.html">2785</a></td> + <td>[<a href="https://wg21.link/temp.dep.expr">temp.dep.expr</a>]</td> <td>CD7</td> <td>Type-dependence of <I>requires-expression</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2786"> <td><a href="https://cplusplus.github.io/CWG/issues/2786.html">2786</a></td> + <td>[<a href="https://wg21.link/expr.eq">expr.eq</a>]</td> <td>open</td> <td>Comparing pointers to complete objects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2787"> <td><a href="https://cplusplus.github.io/CWG/issues/2787.html">2787</a></td> + <td>[<a href="https://wg21.link/special">special</a>]</td> <td>open</td> <td>Kind of explicit object copy/move assignment function</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2788"> <td><a href="https://cplusplus.github.io/CWG/issues/2788.html">2788</a></td> + <td>[<a href="https://wg21.link/basic.scope.scope">basic.scope.scope</a>]</td> <td>open</td> <td>Correspondence and redeclarations</td> <td align="center">Not resolved</td> </tr> <tr id="2789"> <td><a href="https://cplusplus.github.io/CWG/issues/2789.html">2789</a></td> + <td>[<a href="https://wg21.link/over.match.best.general">over.match.best.general</a>]</td> <td>CD7</td> <td>Overload resolution with implicit and explicit object member functions</td> <td class="full" align="center">Clang 18</td> </tr> <tr class="open" id="2790"> <td><a href="https://cplusplus.github.io/CWG/issues/2790.html">2790</a></td> + <td>[<a href="https://wg21.link/over.ics.list">over.ics.list</a>]</td> <td>open</td> <td>Aggregate initialization and user-defined conversion sequence</td> <td align="center">Not resolved</td> </tr> <tr id="2791"> <td><a href="https://cplusplus.github.io/CWG/issues/2791.html">2791</a></td> + <td>[<a href="https://wg21.link/stmt.return">stmt.return</a>]</td> <td>CD7</td> <td>Unclear phrasing about "returning to the caller"</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2792"> <td><a href="https://cplusplus.github.io/CWG/issues/2792.html">2792</a></td> + <td>[<a href="https://wg21.link/expr.unary.noexcept">expr.unary.noexcept</a>]</td> <td>CD7</td> <td>Clean up specification of <TT>noexcept</TT> operator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2793"> <td><a href="https://cplusplus.github.io/CWG/issues/2793.html">2793</a></td> + <td>[<a href="https://wg21.link/basic.scope.block">basic.scope.block</a>]</td> <td>CD7</td> <td>Block-scope declaration conflicting with parameter name</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2794"> <td><a href="https://cplusplus.github.io/CWG/issues/2794.html">2794</a></td> + <td>[<a href="https://wg21.link/temp.alias">temp.alias</a>]</td> <td>open</td> <td>Uniqueness of lambdas in alias templates</td> <td align="center">Not resolved</td> </tr> <tr id="2795"> <td><a href="https://cplusplus.github.io/CWG/issues/2795.html">2795</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>CD7</td> <td>Overlapping empty subobjects with different cv-qualification</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2796"> <td><a href="https://cplusplus.github.io/CWG/issues/2796.html">2796</a></td> + <td>[<a href="https://wg21.link/expr.rel">expr.rel</a>]</td> <td>CD7</td> <td>Function pointer conversions for relational operators</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2797"> <td><a href="https://cplusplus.github.io/CWG/issues/2797.html">2797</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>review</td> <td>Meaning of "corresponds" for rewritten operator candidates</td> <td align="center">Not resolved</td> </tr> <tr id="2798"> <td><a href="https://cplusplus.github.io/CWG/issues/2798.html">2798</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>Manifestly constant evaluation of the <TT>static_assert</TT> message</td> <td class="full" align="center">Clang 17</td> </tr> <tr class="open" id="2799"> <td><a href="https://cplusplus.github.io/CWG/issues/2799.html">2799</a></td> + <td>[<a href="https://wg21.link/class.default.ctor">class.default.ctor</a>]</td> <td>drafting</td> <td>Inheriting default constructors</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2800"> <td><a href="https://cplusplus.github.io/CWG/issues/2800.html">2800</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>review</td> <td>Instantiating constexpr variables for potential constant evaluation</td> <td align="center">Not resolved</td> </tr> <tr id="2801"> <td><a href="https://cplusplus.github.io/CWG/issues/2801.html">2801</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD7</td> <td>Reference binding with reference-related types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2802"> <td><a href="https://cplusplus.github.io/CWG/issues/2802.html">2802</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>open</td> <td>Constrained <TT>auto</TT> and redeclaration with non-abbreviated syntax</td> <td align="center">Not resolved</td> </tr> <tr id="2803"> <td><a href="https://cplusplus.github.io/CWG/issues/2803.html">2803</a></td> + <td>[<a href="https://wg21.link/over.ics.ref">over.ics.ref</a>]</td> <td>CD7</td> <td>Overload resolution for reference binding of similar types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2804"> <td><a href="https://cplusplus.github.io/CWG/issues/2804.html">2804</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>open</td> <td>Lookup for determining rewrite targets</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2805"> <td><a href="https://cplusplus.github.io/CWG/issues/2805.html">2805</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>open</td> <td>Underspecified selection of deallocation function</td> <td align="center">Not resolved</td> </tr> <tr id="2806"> <td><a href="https://cplusplus.github.io/CWG/issues/2806.html">2806</a></td> + <td>[<a href="https://wg21.link/temp.res.general">temp.res.general</a>]</td> <td>CD7</td> <td>Make a <I>type-requirement</I> a type-only context</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2807"> <td><a href="https://cplusplus.github.io/CWG/issues/2807.html">2807</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>CD7</td> <td>Destructors declared <TT>consteval</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2808"> <td><a href="https://cplusplus.github.io/CWG/issues/2808.html">2808</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>review</td> <td>Explicit specialization of defaulted special member function</td> <td align="center">Not resolved</td> </tr> <tr id="2809"> <td><a href="https://cplusplus.github.io/CWG/issues/2809.html">2809</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>CD7</td> <td>An implicit definition does not redeclare a function</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2810"> <td><a href="https://cplusplus.github.io/CWG/issues/2810.html">2810</a></td> + <td>[<a href="https://wg21.link/temp.res.general">temp.res.general</a>]</td> <td>CD7</td> <td>Requiring the absence of diagnostics for templates</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2811"> <td><a href="https://cplusplus.github.io/CWG/issues/2811.html">2811</a></td> + <td>[<a href="https://wg21.link/basic.start.main">basic.start.main</a>]</td> <td>CD7</td> <td>Clarify "use" of main</td> <td class="full" align="center">Clang 3.5</td> </tr> <tr class="open" id="2812"> <td><a href="https://cplusplus.github.io/CWG/issues/2812.html">2812</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>open</td> <td>Allocation with explicit alignment</td> <td align="center">Not resolved</td> </tr> <tr id="2813"> <td><a href="https://cplusplus.github.io/CWG/issues/2813.html">2813</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>CD7</td> <td>Class member access with prvalues</td> <td class="full" align="center">Clang 20</td> </tr> <tr id="2814"> <td><a href="https://cplusplus.github.io/CWG/issues/2814.html">2814</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>NAD</td> <td>Alignment requirement of incomplete class type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2815"> <td><a href="https://cplusplus.github.io/CWG/issues/2815.html">2815</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>CD7</td> <td>Overload resolution for references/pointers to <TT>noexcept</TT> functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2816"> <td><a href="https://cplusplus.github.io/CWG/issues/2816.html">2816</a></td> + <td>[<a href="https://wg21.link/intro.progress">intro.progress</a>]</td> <td>review</td> <td>Unclear phrasing "may assume ... eventually"</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2817"> <td><a href="https://cplusplus.github.io/CWG/issues/2817.html">2817</a></td> + <td>[<a href="https://wg21.link/expr.sizeof">expr.sizeof</a>]</td> <td>open</td> <td>sizeof(abstract class) is underspecified</td> <td align="center">Not resolved</td> </tr> <tr id="2818"> <td><a href="https://cplusplus.github.io/CWG/issues/2818.html">2818</a></td> + <td>[<a href="https://wg21.link/lex.name">lex.name</a>]</td> <td>CD7</td> <td>Use of predefined reserved identifiers</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2819"> <td><a href="https://cplusplus.github.io/CWG/issues/2819.html">2819</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>Cast from null pointer value in a constant expression</td> <td class="full" align="center">Clang 19 (C++26 onwards)</td> </tr> <tr id="2820"> <td><a href="https://cplusplus.github.io/CWG/issues/2820.html">2820</a></td> + <td>[<a href="https://wg21.link/dcl.init.general">dcl.init.general</a>]</td> <td>CD7</td> <td>Value-initialization and default constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2821"> <td><a href="https://cplusplus.github.io/CWG/issues/2821.html">2821</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>review</td> <td>Lifetime, zero-initialization, and dynamic initialization</td> <td align="center">Not resolved</td> </tr> <tr id="2822"> <td><a href="https://cplusplus.github.io/CWG/issues/2822.html">2822</a></td> + <td>[<a href="https://wg21.link/basic.stc.general">basic.stc.general</a>]</td> <td>CD7</td> <td>Side-effect-free pointer zap</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2823"> <td><a href="https://cplusplus.github.io/CWG/issues/2823.html">2823</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>CD7</td> <td>Implicit undefined behavior when dereferencing pointers</td> <td class="none" align="center">No</td> </tr> <tr id="2824"> <td><a href="https://cplusplus.github.io/CWG/issues/2824.html">2824</a></td> + <td>[<a href="https://wg21.link/dcl.init.general">dcl.init.general</a>]</td> <td>CD7</td> <td>Copy-initialization of arrays</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2825"> <td><a href="https://cplusplus.github.io/CWG/issues/2825.html">2825</a></td> + <td>[<a href="https://wg21.link/stmt.ranged">stmt.ranged</a>]</td> <td>CD7</td> <td>Range-based for statement using a <I>braced-init-list</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2826"> <td><a href="https://cplusplus.github.io/CWG/issues/2826.html">2826</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>drafting</td> <td>Missing definition of "temporary expression"</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2827"> <td><a href="https://cplusplus.github.io/CWG/issues/2827.html">2827</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>review</td> <td>Representation of unsigned integral types</td> <td align="center">Not resolved</td> </tr> <tr id="2828"> <td><a href="https://cplusplus.github.io/CWG/issues/2828.html">2828</a></td> + <td>[<a href="https://wg21.link/expr.cast">expr.cast</a>]</td> <td>CD7</td> <td>Ambiguous interpretation of C-style cast</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2829"> <td><a href="https://cplusplus.github.io/CWG/issues/2829.html">2829</a></td> + <td>[<a href="https://wg21.link/over.best.ics.general">over.best.ics.general</a>]</td> <td>open</td> <td>Redundant case in restricting user-defined conversion sequences</td> <td align="center">Not resolved</td> </tr> <tr id="2830"> <td><a href="https://cplusplus.github.io/CWG/issues/2830.html">2830</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD7</td> <td>Top-level cv-qualification should be ignored for list-initialization</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2831"> <td><a href="https://cplusplus.github.io/CWG/issues/2831.html">2831</a></td> + <td>[<a href="https://wg21.link/dcl.decl.general">dcl.decl.general</a>]</td> <td>CD7</td> <td>Non-templated function definitions and <I>requires-clause</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2832"> <td><a href="https://cplusplus.github.io/CWG/issues/2832.html">2832</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>open</td> <td>Invented temporary variables and temporary objects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2833"> <td><a href="https://cplusplus.github.io/CWG/issues/2833.html">2833</a></td> + <td>[<a href="https://wg21.link/basic.start.dynamic">basic.start.dynamic</a>]</td> <td>review</td> <td>Evaluation of odr-use</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2834"> <td><a href="https://cplusplus.github.io/CWG/issues/2834.html">2834</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>review</td> <td>Partial ordering and explicit object parameters</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2835"> <td><a href="https://cplusplus.github.io/CWG/issues/2835.html">2835</a></td> + <td>[<a href="https://wg21.link/basic.scope.scope">basic.scope.scope</a>]</td> <td>open</td> <td>Name-independent declarations</td> <td align="center">Not resolved</td> </tr> <tr id="2836"> <td><a href="https://cplusplus.github.io/CWG/issues/2836.html">2836</a></td> + <td>[<a href="https://wg21.link/conv.rank">conv.rank</a>]</td> <td>CD7</td> <td>Conversion rank of <TT>long double</TT> and extended floating-point types</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2837"> <td><a href="https://cplusplus.github.io/CWG/issues/2837.html">2837</a></td> + <td>[<a href="https://wg21.link/class.copy.ctor">class.copy.ctor</a>]</td> <td>open</td> <td>Instantiating and inheriting by-value copy constructors</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2838"> <td><a href="https://cplusplus.github.io/CWG/issues/2838.html">2838</a></td> + <td>[<a href="https://wg21.link/basic.scope.block">basic.scope.block</a>]</td> <td>open</td> <td>Declaration conflicts in <I>lambda-expression</I>s</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2839"> <td><a href="https://cplusplus.github.io/CWG/issues/2839.html">2839</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>open</td> <td>Explicit destruction of base classes</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2840"> <td><a href="https://cplusplus.github.io/CWG/issues/2840.html">2840</a></td> + <td>[<a href="https://wg21.link/basic.align">basic.align</a>]</td> <td>open</td> <td>Missing requirements for fundamental alignments</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2841"> <td><a href="https://cplusplus.github.io/CWG/issues/2841.html">2841</a></td> + <td>[<a href="https://wg21.link/class.ctor.general">class.ctor.general</a>]</td> <td>open</td> <td>When do const objects start being const?</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2842"> <td><a href="https://cplusplus.github.io/CWG/issues/2842.html">2842</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>open</td> <td>Preferring an <TT>initializer_list</TT> over a single value</td> <td align="center">Not resolved</td> </tr> <tr id="2843"> <td><a href="https://cplusplus.github.io/CWG/issues/2843.html">2843</a></td> + <td>[<a href="https://wg21.link/intro.refs">intro.refs</a>]</td> <td>CD7</td> <td>Undated reference to Unicode makes C++ a moving target</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2844"> <td><a href="https://cplusplus.github.io/CWG/issues/2844.html">2844</a></td> + <td>[<a href="https://wg21.link/over.match.oper">over.match.oper</a>]</td> <td>open</td> <td>Enumerating a finite set of built-in candidates</td> <td align="center">Not resolved</td> </tr> <tr id="2845"> <td><a href="https://cplusplus.github.io/CWG/issues/2845.html">2845</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD7</td> <td>Make the closure type of a captureless lambda a structural type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2846"> <td><a href="https://cplusplus.github.io/CWG/issues/2846.html">2846</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD7</td> <td>Out-of-class definitions of explicit object member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2847"> <td><a href="https://cplusplus.github.io/CWG/issues/2847.html">2847</a></td> + <td>[<a href="https://wg21.link/temp.expl.spec">temp.expl.spec</a>]</td> <td>review</td> <td>Constrained explicit specializations of function templates at class scope</td> <td align="center"> @@ -16942,228 +19746,266 @@ objects</td> </tr> <tr id="2848"> <td><a href="https://cplusplus.github.io/CWG/issues/2848.html">2848</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>CD7</td> <td>Omitting an empty template argument list for explicit instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2849"> <td><a href="https://cplusplus.github.io/CWG/issues/2849.html">2849</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD7</td> <td>Parameter objects are not temporary objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2850"> <td><a href="https://cplusplus.github.io/CWG/issues/2850.html">2850</a></td> + <td>[<a href="https://wg21.link/basic.stc">basic.stc</a>]</td> <td>CD7</td> <td>Unclear storage duration for function parameter objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2851"> <td><a href="https://cplusplus.github.io/CWG/issues/2851.html">2851</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>Allow floating-point conversions in converted constant expressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2852"> <td><a href="https://cplusplus.github.io/CWG/issues/2852.html">2852</a></td> + <td>[<a href="https://wg21.link/class.mem.general">class.mem.general</a>]</td> <td>open</td> <td>Complete-class contexts and class-scope lambdas</td> <td align="center">Not resolved</td> </tr> <tr id="2853"> <td><a href="https://cplusplus.github.io/CWG/issues/2853.html">2853</a></td> + <td>[<a href="https://wg21.link/expr.add">expr.add</a>]</td> <td>CD7</td> <td>Pointer arithmetic with pointer to hypothetical element</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2854"> <td><a href="https://cplusplus.github.io/CWG/issues/2854.html">2854</a></td> + <td>[<a href="https://wg21.link/except.throw">except.throw</a>]</td> <td>CD7</td> <td>Storage duration of exception objects</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2855"> <td><a href="https://cplusplus.github.io/CWG/issues/2855.html">2855</a></td> + <td>[<a href="https://wg21.link/expr.post.incr">expr.post.incr</a>]</td> <td>CD7</td> <td>Undefined behavior in postfix increment</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2856"> <td><a href="https://cplusplus.github.io/CWG/issues/2856.html">2856</a></td> + <td>[<a href="https://wg21.link/over.match.list">over.match.list</a>]</td> <td>CD7</td> <td>Copy-list-initialization with explicit default constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2857"> <td><a href="https://cplusplus.github.io/CWG/issues/2857.html">2857</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>CD7</td> <td>Argument-dependent lookup with incomplete class types</td> <td class="none" align="center">No</td> </tr> <tr id="2858"> <td><a href="https://cplusplus.github.io/CWG/issues/2858.html">2858</a></td> + <td>[<a href="https://wg21.link/expr.prim.id.qual">expr.prim.id.qual</a>]</td> <td>CD7</td> <td>Declarative <I>nested-name-specifier</I>s and <I>pack-index-specifier</I>s</td> <td class="full" align="center">Clang 19</td> </tr> <tr id="2859"> <td><a href="https://cplusplus.github.io/CWG/issues/2859.html">2859</a></td> + <td>[<a href="https://wg21.link/dcl.init.general">dcl.init.general</a>]</td> <td>CD7</td> <td>Value-initialization with multiple default constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2860"> <td><a href="https://cplusplus.github.io/CWG/issues/2860.html">2860</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>dup</td> <td>Remove and fix the term "vacuous initialization"</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2861"> <td><a href="https://cplusplus.github.io/CWG/issues/2861.html">2861</a></td> + <td>[<a href="https://wg21.link/expr.dynamic.cast">expr.dynamic.cast</a>]</td> <td>CD7</td> <td><TT>dynamic_cast</TT> on bad pointer value</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2862"> <td><a href="https://cplusplus.github.io/CWG/issues/2862.html">2862</a></td> + <td>[<a href="https://wg21.link/temp.pre">temp.pre</a>]</td> <td>review</td> <td>Unclear boundaries of template declarations</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2863"> <td><a href="https://cplusplus.github.io/CWG/issues/2863.html">2863</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>drafting</td> <td>Unclear synchronization requirements for object lifetime rules</td> <td align="center">Not resolved</td> </tr> <tr id="2864"> <td><a href="https://cplusplus.github.io/CWG/issues/2864.html">2864</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>CD7</td> <td>Narrowing floating-point conversions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2865"> <td><a href="https://cplusplus.github.io/CWG/issues/2865.html">2865</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD7</td> <td>Regression on result of conditional operator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2866"> <td><a href="https://cplusplus.github.io/CWG/issues/2866.html">2866</a></td> + <td>[<a href="https://wg21.link/dcl.attr">dcl.attr</a>]</td> <td>open</td> <td>Observing the effects of <TT>[[no_unique_address]]</TT></td> <td align="center">Not resolved</td> </tr> <tr id="2867"> <td><a href="https://cplusplus.github.io/CWG/issues/2867.html">2867</a></td> + <td>[<a href="https://wg21.link/dcl.struct.bind">dcl.struct.bind</a>]</td> <td>CD7</td> <td>Order of initialization for structured bindings</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2868"> <td><a href="https://cplusplus.github.io/CWG/issues/2868.html">2868</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>open</td> <td>Self-references in trivially copyable objects as function return values</td> <td align="center">Not resolved</td> </tr> <tr id="2869"> <td><a href="https://cplusplus.github.io/CWG/issues/2869.html">2869</a></td> + <td>[<a href="https://wg21.link/expr.prim.this">expr.prim.this</a>]</td> <td>CD7</td> <td><TT>this</TT> in local classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2870"> <td><a href="https://cplusplus.github.io/CWG/issues/2870.html">2870</a></td> + <td>[<a href="https://wg21.link/lex.string">lex.string</a>]</td> <td>CD7</td> <td>Combining absent <I>encoding-prefix</I>es</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2871"> <td><a href="https://cplusplus.github.io/CWG/issues/2871.html">2871</a></td> + <td>[<a href="https://wg21.link/class.default.ctor">class.default.ctor</a>]</td> <td>CD7</td> <td>User-declared constructor templates inhibiting default constructors</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2872"> <td><a href="https://cplusplus.github.io/CWG/issues/2872.html">2872</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>CD7</td> <td>Linkage and unclear "can be referred to"</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2873"> <td><a href="https://cplusplus.github.io/CWG/issues/2873.html">2873</a></td> + <td>[<a href="https://wg21.link/over.over">over.over</a>]</td> <td>open</td> <td>Taking the address of a function involving template argument deduction</td> <td align="center">Not resolved</td> </tr> <tr id="2874"> <td><a href="https://cplusplus.github.io/CWG/issues/2874.html">2874</a></td> + <td>[<a href="https://wg21.link/dcl.type.elab">dcl.type.elab</a>]</td> <td>CD7</td> <td>Qualified declarations of partial specializations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2875"> <td><a href="https://cplusplus.github.io/CWG/issues/2875.html">2875</a></td> + <td>[<a href="https://wg21.link/diff.expr">diff.expr</a>]</td> <td>tentatively ready</td> <td>Missing support for round-tripping null pointer values through indirection/address operators</td> <td align="center">Not resolved</td> </tr> <tr id="2876"> <td><a href="https://cplusplus.github.io/CWG/issues/2876.html">2876</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.general">dcl.fct.def.general</a>]</td> <td>CD7</td> <td>Disambiguation of <TT>T x = delete("text")</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2877"> <td><a href="https://cplusplus.github.io/CWG/issues/2877.html">2877</a></td> + <td>[<a href="https://wg21.link/enum.udecl">enum.udecl</a>]</td> <td>CD7</td> <td>Type-only lookup for <I>using-enum-declarator</I></td> <td class="full" align="center">Clang 19</td> </tr> <tr class="open" id="2878"> <td><a href="https://cplusplus.github.io/CWG/issues/2878.html">2878</a></td> + <td>[<a href="https://wg21.link/expr.cast">expr.cast</a>]</td> <td>open</td> <td>C-style casts to reference types</td> <td align="center">Not resolved</td> </tr> <tr id="2879"> <td><a href="https://cplusplus.github.io/CWG/issues/2879.html">2879</a></td> + <td>[<a href="https://wg21.link/expr.const.cast">expr.const.cast</a>]</td> <td>CD7</td> <td>Undesired outcomes with <TT>const_cast</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2880"> <td><a href="https://cplusplus.github.io/CWG/issues/2880.html">2880</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>CD7</td> <td>Accessibility check for destructor of incomplete class type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2881"> <td><a href="https://cplusplus.github.io/CWG/issues/2881.html">2881</a></td> + <td>[<a href="https://wg21.link/expr.prim.lambda.closure">expr.prim.lambda.closure</a>]</td> <td>CD7</td> <td>Type restrictions for the explicit object parameter of a lambda</td> <td class="full" align="center">Clang 19</td> </tr> <tr id="2882"> <td><a href="https://cplusplus.github.io/CWG/issues/2882.html">2882</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD7</td> <td>Unclear treatment of conversion to <TT>void</TT></td> <td class="full" align="center">Clang 2.7</td> </tr> <tr id="2883"> <td><a href="https://cplusplus.github.io/CWG/issues/2883.html">2883</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD7</td> <td>Definition of "odr-usable" ignores lambda scopes</td> <td class="none" align="center">No</td> </tr> <tr id="2884"> <td><a href="https://cplusplus.github.io/CWG/issues/2884.html">2884</a></td> + <td>[<a href="https://wg21.link/dcl.type.elab">dcl.type.elab</a>]</td> <td>dup</td> <td>Qualified declarations of partial specializations</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2885"> <td><a href="https://cplusplus.github.io/CWG/issues/2885.html">2885</a></td> + <td>[<a href="https://wg21.link/class.default.ctor">class.default.ctor</a>]</td> <td>review</td> <td>Non-eligible trivial default constructors</td> <td align="center"> @@ -17174,192 +20016,224 @@ objects</td> </tr> <tr id="2886"> <td><a href="https://cplusplus.github.io/CWG/issues/2886.html">2886</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>CD7</td> <td>Temporaries and trivial potentially-throwing special member functions</td> <td class="full" align="center">Clang 9</td> </tr> <tr id="2887"> <td><a href="https://cplusplus.github.io/CWG/issues/2887.html">2887</a></td> + <td>[<a href="https://wg21.link/diff.cpp03.expr">diff.cpp03.expr</a>]</td> <td>CD7</td> <td>Missing compatibility entries for xvalues</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2888"> <td><a href="https://cplusplus.github.io/CWG/issues/2888.html">2888</a></td> + <td>[<a href="https://wg21.link/basic.lookup.argdep">basic.lookup.argdep</a>]</td> <td>review</td> <td>Missing cases for reference and array types for argument-dependent lookup</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2889"> <td><a href="https://cplusplus.github.io/CWG/issues/2889.html">2889</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>open</td> <td>Requiring an accessible destructor for destroying operator delete</td> <td align="center">Not resolved</td> </tr> <tr id="2890"> <td><a href="https://cplusplus.github.io/CWG/issues/2890.html">2890</a></td> + <td>[<a href="https://wg21.link/class.local">class.local</a>]</td> <td>CD7</td> <td>Defining members of local classes</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2891"> <td><a href="https://cplusplus.github.io/CWG/issues/2891.html">2891</a></td> + <td>[<a href="https://wg21.link/implimits">implimits</a>]</td> <td>CD7</td> <td>Normative status of implementation limits</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2892"> <td><a href="https://cplusplus.github.io/CWG/issues/2892.html">2892</a></td> + <td>[<a href="https://wg21.link/expr.arith.conv">expr.arith.conv</a>]</td> <td>CD7</td> <td>Unclear usual arithmetic conversions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2893"> <td><a href="https://cplusplus.github.io/CWG/issues/2893.html">2893</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>NAD</td> <td>Instantiations in discarded <TT>if constexpr</TT> substatements</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2894"> <td><a href="https://cplusplus.github.io/CWG/issues/2894.html">2894</a></td> + <td>[<a href="https://wg21.link/expr.type.conv">expr.type.conv</a>]</td> <td>CD7</td> <td>Functional casts create prvalues of reference type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2895"> <td><a href="https://cplusplus.github.io/CWG/issues/2895.html">2895</a></td> + <td>[<a href="https://wg21.link/dcl.init.general">dcl.init.general</a>]</td> <td>CD7</td> <td>Initialization should ignore the destination type's cv-qualification</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2896"> <td><a href="https://cplusplus.github.io/CWG/issues/2896.html">2896</a></td> + <td>[<a href="https://wg21.link/temp.deduct">temp.deduct</a>]</td> <td>review</td> <td>Template argument deduction involving exception specifications</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2897"> <td><a href="https://cplusplus.github.io/CWG/issues/2897.html">2897</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>open</td> <td>Copying potentially-overlapping union subobjects</td> <td align="center">Not resolved</td> </tr> <tr id="2898"> <td><a href="https://cplusplus.github.io/CWG/issues/2898.html">2898</a></td> + <td>[<a href="https://wg21.link/over.best.ics.general">over.best.ics.general</a>]</td> <td>CD7</td> <td>Clarify implicit conversion sequence from <I>cv</I> <TT>T</TT> to <TT>T</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2899"> <td><a href="https://cplusplus.github.io/CWG/issues/2899.html">2899</a></td> + <td>[<a href="https://wg21.link/conv.lval">conv.lval</a>]</td> <td>CD7</td> <td>Bad value representations should cause undefined behavior</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2900"> <td><a href="https://cplusplus.github.io/CWG/issues/2900.html">2900</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>open</td> <td>Deduction of non-type template arguments with placeholder types</td> <td align="center">Not resolved</td> </tr> <tr id="2901"> <td><a href="https://cplusplus.github.io/CWG/issues/2901.html">2901</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>CD7</td> <td>Unclear semantics for near-match aliased access</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2902"> <td><a href="https://cplusplus.github.io/CWG/issues/2902.html">2902</a></td> + <td>[<a href="https://wg21.link/expr.prim.id.general">expr.prim.id.general</a>]</td> <td>review</td> <td>Implicit <TT>this</TT> transformation outside of permitted contexts</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2903"> <td><a href="https://cplusplus.github.io/CWG/issues/2903.html">2903</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>drafting</td> <td>Can we omit the <TT>template</TT> disambiguator in <I>nested-name-specifier</I>s in type-only contexts?</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2904"> <td><a href="https://cplusplus.github.io/CWG/issues/2904.html">2904</a></td> + <td>[<a href="https://wg21.link/temp.pre">temp.pre</a>]</td> <td>open</td> <td>Introducing <I>template-name</I>s</td> <td align="center">Not resolved</td> </tr> <tr id="2905"> <td><a href="https://cplusplus.github.io/CWG/issues/2905.html">2905</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>CD7</td> <td>Value-dependence of <I>noexcept-expression</I></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2906"> <td><a href="https://cplusplus.github.io/CWG/issues/2906.html">2906</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>CD7</td> <td>Lvalue-to-rvalue conversion of class types for conditional operator</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2907"> <td><a href="https://cplusplus.github.io/CWG/issues/2907.html">2907</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>Constant lvalue-to-rvalue conversion on uninitialized <TT>std::nullptr_t</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2908"> <td><a href="https://cplusplus.github.io/CWG/issues/2908.html">2908</a></td> + <td>[<a href="https://wg21.link/cpp.line">cpp.line</a>]</td> <td>CD7</td> <td>Counting physical source lines for <TT>__LINE__</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2909"> <td><a href="https://cplusplus.github.io/CWG/issues/2909.html">2909</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>Subtle difference between constant-initialized and constexpr</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2910"> <td><a href="https://cplusplus.github.io/CWG/issues/2910.html">2910</a></td> + <td>[<a href="https://wg21.link/basic.def.odr">basic.def.odr</a>]</td> <td>CD7</td> <td>Effect of <I>requirement-parameter-list</I>s on odr-usability</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2911"> <td><a href="https://cplusplus.github.io/CWG/issues/2911.html">2911</a></td> + <td>[<a href="https://wg21.link/expr.prim.req.general">expr.prim.req.general</a>]</td> <td>CD7</td> <td>Unclear meaning of expressions "appearing within" subexpressions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2912"> <td><a href="https://cplusplus.github.io/CWG/issues/2912.html">2912</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>open</td> <td>Too-large value for size in array new</td> <td align="center">Not resolved</td> </tr> <tr id="2913"> <td><a href="https://cplusplus.github.io/CWG/issues/2913.html">2913</a></td> + <td>[<a href="https://wg21.link/temp.deduct.guide">temp.deduct.guide</a>]</td> <td>CD7</td> <td>Grammar for <I>deduction-guide</I> has <I>requires-clause</I> in the wrong position</td> <td class="full" align="center">Clang 20</td> </tr> <tr class="open" id="2914"> <td><a href="https://cplusplus.github.io/CWG/issues/2914.html">2914</a></td> + <td>[<a href="https://wg21.link/basic.start.static">basic.start.static</a>]</td> <td>review</td> <td>Unclear order of initialization of static and thread-local variables</td> <td align="center">Not resolved</td> </tr> <tr id="2915"> <td><a href="https://cplusplus.github.io/CWG/issues/2915.html">2915</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>CD7</td> <td>Explicit object parameters of type <TT>void</TT></td> <td class="full" align="center">Clang 20</td> </tr> <tr class="open" id="2916"> <td><a href="https://cplusplus.github.io/CWG/issues/2916.html">2916</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial">temp.spec.partial</a>]</td> <td>review</td> <td>Variable template partial specializations should not be declared <TT>static</TT></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2917"> <td><a href="https://cplusplus.github.io/CWG/issues/2917.html">2917</a></td> + <td>[<a href="https://wg21.link/temp.pre">temp.pre</a>]</td> <td>review</td> <td>Disallow multiple <I>friend-type-specifier</I>s for a friend template</td> <td align="center"> @@ -17370,528 +20244,616 @@ objects</td> </tr> <tr id="2918"> <td><a href="https://cplusplus.github.io/CWG/issues/2918.html">2918</a></td> + <td>[<a href="https://wg21.link/over.over">over.over</a>]</td> <td>CD7</td> <td>Consideration of constraints for address of overloaded function</td> <td class="full" align="center">Clang 21</td> </tr> <tr id="2919"> <td><a href="https://cplusplus.github.io/CWG/issues/2919.html">2919</a></td> + <td>[<a href="https://wg21.link/over.match.ref">over.match.ref</a>]</td> <td>CD7</td> <td>Conversion function candidates for initialization of const lvalue reference</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2920"> <td><a href="https://cplusplus.github.io/CWG/issues/2920.html">2920</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>open</td> <td>The <TT>template</TT> keyword for base classes</td> <td align="center">Not resolved</td> </tr> <tr id="2921"> <td><a href="https://cplusplus.github.io/CWG/issues/2921.html">2921</a></td> + <td>[<a href="https://wg21.link/module.interface">module.interface</a>]</td> <td>CD7</td> <td>Exporting redeclarations of entities not attached to a named module</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2922"> <td><a href="https://cplusplus.github.io/CWG/issues/2922.html">2922</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>CD7</td> <td>constexpr placement-new is too permissive</td> <td class="full" align="center">Clang 20</td> </tr> <tr class="open" id="2923"> <td><a href="https://cplusplus.github.io/CWG/issues/2923.html">2923</a></td> + <td>[<a href="https://wg21.link/intro.progress">intro.progress</a>]</td> <td>tentatively ready</td> <td>Note about infinite loops and execution steps</td> <td align="center">Not resolved</td> </tr> <tr id="2924"> <td><a href="https://cplusplus.github.io/CWG/issues/2924.html">2924</a></td> + <td>[<a href="https://wg21.link/defns.undefined">defns.undefined</a>]</td> <td>CD7</td> <td>Undefined behavior during constant evaluation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2925"> <td><a href="https://cplusplus.github.io/CWG/issues/2925.html">2925</a></td> + <td>[<a href="https://wg21.link/expr.delete">expr.delete</a>]</td> <td>NAD</td> <td>Deleting a pointer to an incomplete enumeration type</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2926"> <td><a href="https://cplusplus.github.io/CWG/issues/2926.html">2926</a></td> + <td>[<a href="https://wg21.link/basic.lookup.qual.general">basic.lookup.qual.general</a>]</td> <td>drafting</td> <td>Lookup context for dependent qualified names</td> <td align="center">Not resolved</td> </tr> <tr id="2927"> <td><a href="https://cplusplus.github.io/CWG/issues/2927.html">2927</a></td> + <td>[<a href="https://wg21.link/cpp.pre">cpp.pre</a>]</td> <td>CD7</td> <td>Unclear status of translation unit with <TT>module</TT> keyword</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2928"> <td><a href="https://cplusplus.github.io/CWG/issues/2928.html">2928</a></td> + <td>[<a href="https://wg21.link/basic.start.dynamic">basic.start.dynamic</a>]</td> <td>open</td> <td>No ordering for initializing thread-local variables</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2929"> <td><a href="https://cplusplus.github.io/CWG/issues/2929.html">2929</a></td> + <td>[<a href="https://wg21.link/basic.start.term">basic.start.term</a>]</td> <td>review</td> <td>Lifetime of trivially-destructible static or thread-local objects</td> <td align="center">Not resolved</td> </tr> <tr id="2930"> <td><a href="https://cplusplus.github.io/CWG/issues/2930.html">2930</a></td> + <td>[<a href="https://wg21.link/class.copy.elision">class.copy.elision</a>]</td> <td>CD7</td> <td>Unclear term "copy/move operation" in specification of copy elision</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2931"> <td><a href="https://cplusplus.github.io/CWG/issues/2931.html">2931</a></td> + <td>[<a href="https://wg21.link/over.oper.general">over.oper.general</a>]</td> <td>CD7</td> <td>Restrictions on operator functions that are explicit object member functions</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2932"> <td><a href="https://cplusplus.github.io/CWG/issues/2932.html">2932</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>review</td> <td>Value range of empty enumeration</td> <td align="center">Not resolved</td> </tr> <tr id="2933"> <td><a href="https://cplusplus.github.io/CWG/issues/2933.html">2933</a></td> + <td>[<a href="https://wg21.link/expr.type">expr.type</a>]</td> <td>CD7</td> <td>Dangling references</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2934"> <td><a href="https://cplusplus.github.io/CWG/issues/2934.html">2934</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.coroutine">dcl.fct.def.coroutine</a>]</td> <td>open</td> <td>Unclear semantics of exception escaping from <TT>unhandled_exception</TT></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2935"> <td><a href="https://cplusplus.github.io/CWG/issues/2935.html">2935</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.coroutine">dcl.fct.def.coroutine</a>]</td> <td>open</td> <td>Destroying the coroutine state when initial-await-resume-called is false</td> <td align="center">Not resolved</td> </tr> <tr id="2936"> <td><a href="https://cplusplus.github.io/CWG/issues/2936.html">2936</a></td> + <td>[<a href="https://wg21.link/temp.dep.type">temp.dep.type</a>]</td> <td>CD7</td> <td>Local classes of templated functions should be part of the current instantiation</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2937"> <td><a href="https://cplusplus.github.io/CWG/issues/2937.html">2937</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>CD7</td> <td>Grammar for <I>preprocessing-file</I> has no normative effect</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2938"> <td><a href="https://cplusplus.github.io/CWG/issues/2938.html">2938</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>open</td> <td>Inheriting linkage from a previous declaration</td> <td align="center">Not resolved</td> </tr> <tr id="2939"> <td><a href="https://cplusplus.github.io/CWG/issues/2939.html">2939</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>CD7</td> <td>Do not allow <TT>reinterpret_cast</TT> from prvalue to rvalue reference</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2940"> <td><a href="https://cplusplus.github.io/CWG/issues/2940.html">2940</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>review</td> <td>Definition of "object"</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2941"> <td><a href="https://cplusplus.github.io/CWG/issues/2941.html">2941</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>open</td> <td>Lifetime extension for function-style cast to reference type</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2942"> <td><a href="https://cplusplus.github.io/CWG/issues/2942.html">2942</a></td> + <td>[<a href="https://wg21.link/dcl.fct">dcl.fct</a>]</td> <td>open</td> <td>Packs in a function's parameter-type-list</td> <td align="center">Not resolved</td> </tr> <tr id="2943"> <td><a href="https://cplusplus.github.io/CWG/issues/2943.html">2943</a></td> + <td>[<a href="https://wg21.link/dcl.attr.nodiscard">dcl.attr.nodiscard</a>]</td> <td>CD7</td> <td>Discarding a void return value</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="2944"> <td><a href="https://cplusplus.github.io/CWG/issues/2944.html">2944</a></td> + <td>[<a href="https://wg21.link/expr.throw">expr.throw</a>]</td> <td>CD7</td> <td>Unsequenced <I>throw-expression</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2945"> <td><a href="https://cplusplus.github.io/CWG/issues/2945.html">2945</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>open</td> <td>Redundant constraints on matching function template declarations</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2946"> <td><a href="https://cplusplus.github.io/CWG/issues/2946.html">2946</a></td> + <td>[<a href="https://wg21.link/temp.over.link">temp.over.link</a>]</td> <td>open</td> <td>Dependent call equivalence in non-ADL cases</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2947"> <td><a href="https://cplusplus.github.io/CWG/issues/2947.html">2947</a></td> + <td>[<a href="https://wg21.link/cpp.module">cpp.module</a>]</td> <td>open</td> <td>Limiting macro expansion in <I>pp-module</I></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2948"> <td><a href="https://cplusplus.github.io/CWG/issues/2948.html">2948</a></td> + <td>[<a href="https://wg21.link/temp.spec.partial.general">temp.spec.partial.general</a>]</td> <td>open</td> <td>Late ambiguity for partial template specialization</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2949"> <td><a href="https://cplusplus.github.io/CWG/issues/2949.html">2949</a></td> + <td>[<a href="https://wg21.link/temp.func.order">temp.func.order</a>]</td> <td>open</td> <td>Treatment of ellipsis during partial ordering</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2950"> <td><a href="https://cplusplus.github.io/CWG/issues/2950.html">2950</a></td> + <td>[<a href="https://wg21.link/class.bit">class.bit</a>]</td> <td>open</td> <td>Value preservation in enumeration vs. integer bit-fields</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2951"> <td><a href="https://cplusplus.github.io/CWG/issues/2951.html">2951</a></td> + <td>[<a href="https://wg21.link/temp.decls.general">temp.decls.general</a>]</td> <td>open</td> <td>Distinguishing a primary template</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2952"> <td><a href="https://cplusplus.github.io/CWG/issues/2952.html">2952</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>open</td> <td>Vacuous initialization for subobjects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2953"> <td><a href="https://cplusplus.github.io/CWG/issues/2953.html">2953</a></td> + <td>[<a href="https://wg21.link/basic.types.general">basic.types.general</a>]</td> <td>open</td> <td>Value representation for non-trivially-copyable types</td> <td align="center">Not resolved</td> </tr> <tr id="2954"> <td><a href="https://cplusplus.github.io/CWG/issues/2954.html">2954</a></td> + <td>[<a href="https://wg21.link/intro.races">intro.races</a>]</td> <td>NAD</td> <td>Simultaneous modifications of an atomic object</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2955"> <td><a href="https://cplusplus.github.io/CWG/issues/2955.html">2955</a></td> + <td>[<a href="https://wg21.link/intro.execution">intro.execution</a>]</td> <td>open</td> <td>Unify rules about conflicting unordered accesses</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2956"> <td><a href="https://cplusplus.github.io/CWG/issues/2956.html">2956</a></td> + <td>[<a href="https://wg21.link/basic.lookup.qual.general">basic.lookup.qual.general</a>]</td> <td>open</td> <td>Missing allowance for pseudo-destructors in qualified lookup</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2957"> <td><a href="https://cplusplus.github.io/CWG/issues/2957.html">2957</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>open</td> <td>Evaluating a reference member should constitute access</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2958"> <td><a href="https://cplusplus.github.io/CWG/issues/2958.html">2958</a></td> + <td>[<a href="https://wg21.link/over.ics.rank">over.ics.rank</a>]</td> <td>open</td> <td>Overload resolution involving lvalue transformation and qualification conversion</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2959"> <td><a href="https://cplusplus.github.io/CWG/issues/2959.html">2959</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>open</td> <td>Naming enumerators in class member access expressions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2960"> <td><a href="https://cplusplus.github.io/CWG/issues/2960.html">2960</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>open</td> <td>Introduce discontiguous object lifetime</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2961"> <td><a href="https://cplusplus.github.io/CWG/issues/2961.html">2961</a></td> + <td>[<a href="https://wg21.link/temp.constr">temp.constr</a>]</td> <td>open</td> <td>Checking of ill-formed types in <I>constraint-expression</I>s</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2962"> <td><a href="https://cplusplus.github.io/CWG/issues/2962.html">2962</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Evaluation of destructor call for variable with constant destruction</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2963"> <td><a href="https://cplusplus.github.io/CWG/issues/2963.html">2963</a></td> + <td>[<a href="https://wg21.link/stmt.ambig">stmt.ambig</a>]</td> <td>open</td> <td>Paradoxical variable-or-function declaration</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2964"> <td><a href="https://cplusplus.github.io/CWG/issues/2964.html">2964</a></td> + <td>[<a href="https://wg21.link/conv.lval">conv.lval</a>]</td> <td>open</td> <td>Reading "invalid pointer values"</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2965"> <td><a href="https://cplusplus.github.io/CWG/issues/2965.html">2965</a></td> + <td>[<a href="https://wg21.link/basic.scope.temp">basic.scope.temp</a>]</td> <td>open</td> <td>Generic lambdas do not have a template parameter scope</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2966"> <td><a href="https://cplusplus.github.io/CWG/issues/2966.html">2966</a></td> + <td>[<a href="https://wg21.link/basic.fundamental">basic.fundamental</a>]</td> <td>open</td> <td>Alignment and value representation of <TT>std::nullptr_t</TT></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2967"> <td><a href="https://cplusplus.github.io/CWG/issues/2967.html">2967</a></td> + <td>[<a href="https://wg21.link/over.match.ref">over.match.ref</a>]</td> <td>open</td> <td>Explicit conversion functions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2968"> <td><a href="https://cplusplus.github.io/CWG/issues/2968.html">2968</a></td> + <td>[<a href="https://wg21.link/basic.lookup.general">basic.lookup.general</a>]</td> <td>open</td> <td>Name lookup result for <I>typedef-name</I> vs. <I>class-name</I></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2969"> <td><a href="https://cplusplus.github.io/CWG/issues/2969.html">2969</a></td> + <td>[<a href="https://wg21.link/basic.scope">basic.scope</a>]</td> <td>open</td> <td>Scopes in the <I>function-try-block</I> of a constructor</td> <td align="center">Not resolved</td> </tr> <tr id="2970"> <td><a href="https://cplusplus.github.io/CWG/issues/2970.html">2970</a></td> + <td>[<a href="https://wg21.link/intro.races">intro.races</a>]</td> <td>CD7</td> <td>Races with <TT>volatile sig_atomic_t</TT> bit-fields</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2971"> <td><a href="https://cplusplus.github.io/CWG/issues/2971.html">2971</a></td> + <td>[<a href="https://wg21.link/module.global.frag">module.global.frag</a>]</td> <td>open</td> <td>Specializations for a class are not decl-reachable</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2972"> <td><a href="https://cplusplus.github.io/CWG/issues/2972.html">2972</a></td> + <td>[<a href="https://wg21.link/expr.prim.id.qual">expr.prim.id.qual</a>]</td> <td>open</td> <td>Declarative <I>nested-name-specifier</I> naming a partial specialization</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2973"> <td><a href="https://cplusplus.github.io/CWG/issues/2973.html">2973</a></td> + <td>[<a href="https://wg21.link/dcl.typedef">dcl.typedef</a>]</td> <td>open</td> <td>Does an <I>alias-declaration</I> introduce a name for linkage purposes?</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2974"> <td><a href="https://cplusplus.github.io/CWG/issues/2974.html">2974</a></td> + <td>[<a href="https://wg21.link/temp.deduct.type">temp.deduct.type</a>]</td> <td>open</td> <td>Non-deduced context for <I>qualified-id</I> naming a template</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2975"> <td><a href="https://cplusplus.github.io/CWG/issues/2975.html">2975</a></td> + <td>[<a href="https://wg21.link/temp.constr.normal">temp.constr.normal</a>]</td> <td>open</td> <td>Effect of concept <I>template-head</I> on parameter mappings</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2976"> <td><a href="https://cplusplus.github.io/CWG/issues/2976.html">2976</a></td> + <td>[<a href="https://wg21.link/stmt.dcl">stmt.dcl</a>]</td> <td>review</td> <td>Transferring control out of a function</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2977"> <td><a href="https://cplusplus.github.io/CWG/issues/2977.html">2977</a></td> + <td>[<a href="https://wg21.link/dcl.init.general">dcl.init.general</a>]</td> <td>review</td> <td>Initialization with string literals</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2978"> <td><a href="https://cplusplus.github.io/CWG/issues/2978.html">2978</a></td> + <td>[<a href="https://wg21.link/temp.deduct.call">temp.deduct.call</a>]</td> <td>open</td> <td>Deduction involving reference to similar types</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2979"> <td><a href="https://cplusplus.github.io/CWG/issues/2979.html">2979</a></td> + <td>[<a href="https://wg21.link/class.mem.general">class.mem.general</a>]</td> <td>open</td> <td>Duplicate declarations of enumerations in class scope</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2980"> <td><a href="https://cplusplus.github.io/CWG/issues/2980.html">2980</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>open</td> <td>Constraints on template template parameters</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2981"> <td><a href="https://cplusplus.github.io/CWG/issues/2981.html">2981</a></td> + <td>[<a href="https://wg21.link/expr.arith.conv">expr.arith.conv</a>]</td> <td>open</td> <td>Usual arithmetic conversions and result types</td> <td align="center">Not resolved</td> </tr> <tr id="2982"> <td><a href="https://cplusplus.github.io/CWG/issues/2982.html">2982</a></td> + <td>[<a href="https://wg21.link/temp.deduct.decl">temp.deduct.decl</a>]</td> <td>CD7</td> <td>Deduction in <I>type-constraint</I>s</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2983"> <td><a href="https://cplusplus.github.io/CWG/issues/2983.html">2983</a></td> + <td>[<a href="https://wg21.link/basic.pre">basic.pre</a>]</td> <td>review</td> <td>Non-type template parameters are not variables</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2984"> <td><a href="https://cplusplus.github.io/CWG/issues/2984.html">2984</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>open</td> <td>Value-dependent structured bindings</td> <td align="center">Not resolved</td> </tr> <tr id="2985"> <td><a href="https://cplusplus.github.io/CWG/issues/2985.html">2985</a></td> + <td>[<a href="https://wg21.link/dcl.init.ref">dcl.init.ref</a>]</td> <td>CD7</td> <td>Unclear rules for reference initialization with conversion</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2986"> <td><a href="https://cplusplus.github.io/CWG/issues/2986.html">2986</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>open</td> <td>Creating objects within a mutable member of a const object</td> <td align="center">Not resolved</td> </tr> <tr id="2987"> <td><a href="https://cplusplus.github.io/CWG/issues/2987.html">2987</a></td> + <td>[<a href="https://wg21.link/expr.static.cast">expr.static.cast</a>]</td> <td>CD7</td> <td>Remove dilapidated wording from <TT>static_cast</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2988"> <td><a href="https://cplusplus.github.io/CWG/issues/2988.html">2988</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>open</td> <td>Is a closure type from a <I>lambda-expression</I> appearing in a <I>concept-definition</I> a TU-local entity?</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2989"> <td><a href="https://cplusplus.github.io/CWG/issues/2989.html">2989</a></td> + <td>[<a href="https://wg21.link/expr.prim.paren">expr.prim.paren</a>]</td> <td>open</td> <td>Remove misleading general allowance for parentheses</td> <td align="center">Not resolved</td> </tr> <tr id="2990"> <td><a href="https://cplusplus.github.io/CWG/issues/2990.html">2990</a></td> + <td>[<a href="https://wg21.link/module.interface">module.interface</a>]</td> <td>CD7</td> <td>Exporting redeclarations of namespaces</td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="2991"> <td><a href="https://cplusplus.github.io/CWG/issues/2991.html">2991</a></td> + <td>[<a href="https://wg21.link/dcl.init.general">dcl.init.general</a>]</td> <td>open</td> <td>"array size" is vague</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2992"> <td><a href="https://cplusplus.github.io/CWG/issues/2992.html">2992</a></td> + <td>[<a href="https://wg21.link/basic.pre">basic.pre</a>]</td> <td>open</td> <td>Labels do not have names</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2993"> <td><a href="https://cplusplus.github.io/CWG/issues/2993.html">2993</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.general">dcl.fct.def.general</a>]</td> <td>open</td> <td>Body of a destructor</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2994"> <td><a href="https://cplusplus.github.io/CWG/issues/2994.html">2994</a></td> + <td>[<a href="https://wg21.link/temp.param">temp.param</a>]</td> <td>open</td> <td>Allowing template parameters following template parameter packs that are pack expansions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2995"> <td><a href="https://cplusplus.github.io/CWG/issues/2995.html">2995</a></td> + <td>[<a href="https://wg21.link/stmt.return">stmt.return</a>]</td> <td>open</td> <td>Meaning of flowing off the end of a function</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2996"> <td><a href="https://cplusplus.github.io/CWG/issues/2996.html">2996</a></td> + <td>[<a href="https://wg21.link/temp.constr.atomic">temp.constr.atomic</a>]</td> <td>open</td> <td>Impenetrable definition of atomic constraint</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2997"> <td><a href="https://cplusplus.github.io/CWG/issues/2997.html">2997</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.default">dcl.fct.def.default</a>]</td> <td>open</td> <td>Defaulted functions with deleted definition</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2998"> <td><a href="https://cplusplus.github.io/CWG/issues/2998.html">2998</a></td> + <td>[<a href="https://wg21.link/temp.deduct.partial">temp.deduct.partial</a>]</td> <td>open</td> <td>Missing deduction consistency check for partial ordering</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="2999"> <td><a href="https://cplusplus.github.io/CWG/issues/2999.html">2999</a></td> + <td>[<a href="https://wg21.link/class.default.ctor">class.default.ctor</a>]</td> <td>open</td> <td>Trivial unions changing existing behavior</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3000"> <td><a href="https://cplusplus.github.io/CWG/issues/3000.html">3000</a></td> + <td>[<a href="https://wg21.link/expr.cond">expr.cond</a>]</td> <td>review</td> <td>Handling of cv-qualified class types in conditional operator</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3001"> <td><a href="https://cplusplus.github.io/CWG/issues/3001.html">3001</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>tentatively ready</td> <td>Inconsistent restrictions for <TT>static_cast</TT> on pointers to out-of-lifetime objects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3002"> <td><a href="https://cplusplus.github.io/CWG/issues/3002.html">3002</a></td> + <td>[<a href="https://wg21.link/temp.dep.temp">temp.dep.temp</a>]</td> <td>tentatively ready</td> <td>Template parameter/argument confusion</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3003"> <td><a href="https://cplusplus.github.io/CWG/issues/3003.html">3003</a></td> + <td>[<a href="https://wg21.link/dcl.type.simple">dcl.type.simple</a>]</td> <td>review</td> <td>Naming a deducible template for class template argument deduction</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3004"> <td><a href="https://cplusplus.github.io/CWG/issues/3004.html">3004</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>tentatively ready</td> <td>Pointer arithmetic on array of unknown bound</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3005"> <td><a href="https://cplusplus.github.io/CWG/issues/3005.html">3005</a></td> + <td>[<a href="https://wg21.link/basic.scope.scope">basic.scope.scope</a>]</td> <td>tentatively ready</td> <td>Function parameters should never be name-independent</td> <td align="center"> @@ -17902,570 +20864,665 @@ objects</td> </tr> <tr class="open" id="3006"> <td><a href="https://cplusplus.github.io/CWG/issues/3006.html">3006</a></td> + <td>[<a href="https://wg21.link/temp.explicit">temp.explicit</a>]</td> <td>review</td> <td>Vague restrictions for explicit instantiations of class templates</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3007"> <td><a href="https://cplusplus.github.io/CWG/issues/3007.html">3007</a></td> + <td>[<a href="https://wg21.link/class.compare.default">class.compare.default</a>]</td> <td>open</td> <td>Access checking during synthesis of defaulted comparison operator, take 2</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3008"> <td><a href="https://cplusplus.github.io/CWG/issues/3008.html">3008</a></td> + <td>[<a href="https://wg21.link/diff.dcl">diff.dcl</a>]</td> <td>tentatively ready</td> <td>Missing Annex C entry for <TT>void</TT> object declarations</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3009"> <td><a href="https://cplusplus.github.io/CWG/issues/3009.html">3009</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>Unclear rules for constant initialization</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3010"> <td><a href="https://cplusplus.github.io/CWG/issues/3010.html">3010</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td>constexpr placement-new should require transparent replaceability</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3011"> <td><a href="https://cplusplus.github.io/CWG/issues/3011.html">3011</a></td> + <td>[<a href="https://wg21.link/expr.new">expr.new</a>]</td> <td>tentatively ready</td> <td>Parenthesized aggregate initialization for <I>new-expression</I>s</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3012"> <td><a href="https://cplusplus.github.io/CWG/issues/3012.html">3012</a></td> + <td>[<a href="https://wg21.link/dcl.constexpr">dcl.constexpr</a>]</td> <td>open</td> <td>Deviating <TT>constexpr</TT> or <TT>consteval</TT> across translation units</td> <td align="center">Not resolved</td> </tr> <tr id="3013"> <td><a href="https://cplusplus.github.io/CWG/issues/3013.html">3013</a></td> + <td>[<a href="https://wg21.link/cpp.embed.gen">cpp.embed.gen</a>]</td> <td>CD7</td> <td>Disallowing macros for <TT>#embed</TT> parameters</td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="3014"> <td><a href="https://cplusplus.github.io/CWG/issues/3014.html">3014</a></td> + <td>[<a href="https://wg21.link/cpp.embed.gen">cpp.embed.gen</a>]</td> <td>CD7</td> <td>Comma-delimited vs. comma-separated output for <TT>#embed</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="3015"> <td><a href="https://cplusplus.github.io/CWG/issues/3015.html">3015</a></td> + <td>[<a href="https://wg21.link/cpp.include">cpp.include</a>]</td> <td>CD7</td> <td>Handling of <I>header-name</I>s for <TT>#include</TT> and <TT>#embed</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr id="3016"> <td><a href="https://cplusplus.github.io/CWG/issues/3016.html">3016</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>CD7</td> <td>Satisfying the syntactic requirements of <TT>#include</TT> and <TT>#embed</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="3017"> <td><a href="https://cplusplus.github.io/CWG/issues/3017.html">3017</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>open</td> <td>Commas in controlling expression of conditional inclusion</td> <td align="center">Not resolved</td> </tr> <tr id="3018"> <td><a href="https://cplusplus.github.io/CWG/issues/3018.html">3018</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>CD7</td> <td>Validity of <TT>defined</TT> in <TT>__has_embed</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="3019"> <td><a href="https://cplusplus.github.io/CWG/issues/3019.html">3019</a></td> + <td>[<a href="https://wg21.link/lex.header">lex.header</a>]</td> <td>open</td> <td>Restrictions on character sequences in <I>header-name</I>s</td> <td align="center">Not resolved</td> </tr> <tr id="3020"> <td><a href="https://cplusplus.github.io/CWG/issues/3020.html">3020</a></td> + <td>[<a href="https://wg21.link/cpp.cond">cpp.cond</a>]</td> <td>CD7</td> <td>Missing specification for <TT>__has_cpp_attribute(indeterminate)</TT></td> <td class="unknown" align="center">Unknown</td> </tr> <tr class="open" id="3021"> <td><a href="https://cplusplus.github.io/CWG/issues/3021.html">3021</a></td> + <td>[<a href="https://wg21.link/temp.constr.order">temp.constr.order</a>]</td> <td>drafting</td> <td>Subsumption rules for fold expanded constraints</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3022"> <td><a href="https://cplusplus.github.io/CWG/issues/3022.html">3022</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>review</td> <td>Redundant specification of explicit destructor calls</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3023"> <td><a href="https://cplusplus.github.io/CWG/issues/3023.html">3023</a></td> + <td>[<a href="https://wg21.link/dcl.init.list">dcl.init.list</a>]</td> <td>open</td> <td>Default arguments in list-initialization</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3024"> <td><a href="https://cplusplus.github.io/CWG/issues/3024.html">3024</a></td> + <td>[<a href="https://wg21.link/dcl.align">dcl.align</a>]</td> <td>open</td> <td>Alignment of references</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3025"> <td><a href="https://cplusplus.github.io/CWG/issues/3025.html">3025</a></td> + <td>[<a href="https://wg21.link/basic.stc.dynamic.deallocation">basic.stc.dynamic.deallocation</a>]</td> <td>open</td> <td>Deallocation functions returning void</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3026"> <td><a href="https://cplusplus.github.io/CWG/issues/3026.html">3026</a></td> + <td>[<a href="https://wg21.link/expr.unary.op">expr.unary.op</a>]</td> <td>open</td> <td>Class for pointer-to-member formation</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3027"> <td><a href="https://cplusplus.github.io/CWG/issues/3027.html">3027</a></td> + <td>[<a href="https://wg21.link/temp.type">temp.type</a>]</td> <td>open</td> <td>Equivalence of <I>pack-index-specifier</I>s</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3028"> <td><a href="https://cplusplus.github.io/CWG/issues/3028.html">3028</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>open</td> <td>A <I>using-declarator</I> should bind a name</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3029"> <td><a href="https://cplusplus.github.io/CWG/issues/3029.html">3029</a></td> + <td>[<a href="https://wg21.link/basic.align">basic.align</a>]</td> <td>drafting</td> <td>Confusing note about ordinary character types for aligned memory areas</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3030"> <td><a href="https://cplusplus.github.io/CWG/issues/3030.html">3030</a></td> + <td>[<a href="https://wg21.link/dcl.array">dcl.array</a>]</td> <td>open</td> <td>Initializing array prvalues of unknown bound</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3031"> <td><a href="https://cplusplus.github.io/CWG/issues/3031.html">3031</a></td> + <td>[<a href="https://wg21.link/over.match.funcs.general">over.match.funcs.general</a>]</td> <td>open</td> <td>Finding declarations for conversion operators for access checking</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3032"> <td><a href="https://cplusplus.github.io/CWG/issues/3032.html">3032</a></td> + <td>[<a href="https://wg21.link/temp.arg.general">temp.arg.general</a>]</td> <td>tentatively ready</td> <td>Template argument disambiguation</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3033"> <td><a href="https://cplusplus.github.io/CWG/issues/3033.html">3033</a></td> + <td>[<a href="https://wg21.link/basic.scope.namespace">basic.scope.namespace</a>]</td> <td>open</td> <td>Scope after <I>declarator-id</I> before determining correspondence</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3034"> <td><a href="https://cplusplus.github.io/CWG/issues/3034.html">3034</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>open</td> <td>Infinite recursion should hit an implementation limit</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3035"> <td><a href="https://cplusplus.github.io/CWG/issues/3035.html">3035</a></td> + <td>[<a href="https://wg21.link/class.union.anon">class.union.anon</a>]</td> <td>open</td> <td>Lambda expressions in anonymous unions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3036"> <td><a href="https://cplusplus.github.io/CWG/issues/3036.html">3036</a></td> + <td>[<a href="https://wg21.link/basic.extended.fp">basic.extended.fp</a>]</td> <td>open</td> <td>Extended floating-point types should not be cv-qualified</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3037"> <td><a href="https://cplusplus.github.io/CWG/issues/3037.html">3037</a></td> + <td>[<a href="https://wg21.link/namespace.udecl">namespace.udecl</a>]</td> <td>open</td> <td>Name lookup results for <I>using-declarator</I>s</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3038"> <td><a href="https://cplusplus.github.io/CWG/issues/3038.html">3038</a></td> + <td>[<a href="https://wg21.link/dcl.attr.grammar">dcl.attr.grammar</a>]</td> <td>open</td> <td>Ignorability of attributes, again</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3039"> <td><a href="https://cplusplus.github.io/CWG/issues/3039.html">3039</a></td> + <td>[<a href="https://wg21.link/intro.object">intro.object</a>]</td> <td>open</td> <td>Undefined behavior from implicit object creation ignores observable checkpoints</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3040"> <td><a href="https://cplusplus.github.io/CWG/issues/3040.html">3040</a></td> + <td>[<a href="https://wg21.link/dcl.fct.def.coroutine">dcl.fct.def.coroutine</a>]</td> <td>open</td> <td>Mishandling of lambda coroutines</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3041"> <td><a href="https://cplusplus.github.io/CWG/issues/3041.html">3041</a></td> + <td>[<a href="https://wg21.link/class.dtor">class.dtor</a>]</td> <td>open</td> <td>Overly aggressive rule for deleting the destructor of a union</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3042"> <td><a href="https://cplusplus.github.io/CWG/issues/3042.html">3042</a></td> + <td>[<a href="https://wg21.link/basic.lval">basic.lval</a>]</td> <td>open</td> <td>Implicit object creation is insufficient to model effective type rule of C</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3043"> <td><a href="https://cplusplus.github.io/CWG/issues/3043.html">3043</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>open</td> <td>Lifetime extension for temporaries in expansion statements</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3044"> <td><a href="https://cplusplus.github.io/CWG/issues/3044.html">3044</a></td> + <td>[<a href="https://wg21.link/stmt.expand">stmt.expand</a>]</td> <td>tentatively ready</td> <td>Iterating expansion statements woes</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3045"> <td><a href="https://cplusplus.github.io/CWG/issues/3045.html">3045</a></td> + <td>[<a href="https://wg21.link/basic.scope.block">basic.scope.block</a>]</td> <td>tentatively ready</td> <td>Regularizing environment interactions of expansion statement</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3046"> <td><a href="https://cplusplus.github.io/CWG/issues/3046.html">3046</a></td> + <td>[<a href="https://wg21.link/dcl.enum">dcl.enum</a>]</td> <td>open</td> <td>Enumerations as part of the common initial sequence</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3047"> <td><a href="https://cplusplus.github.io/CWG/issues/3047.html">3047</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>open</td> <td>Calling destructors on out-of-lifetime objects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3048"> <td><a href="https://cplusplus.github.io/CWG/issues/3048.html">3048</a></td> + <td>[<a href="https://wg21.link/stmt.expand">stmt.expand</a>]</td> <td>tentatively ready</td> <td>Empty destructuring expansion statements</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3049"> <td><a href="https://cplusplus.github.io/CWG/issues/3049.html">3049</a></td> + <td>[<a href="https://wg21.link/class.prop">class.prop</a>]</td> <td>open</td> <td>Implicitly deleted move operation should not disable trivial relocation</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3050"> <td><a href="https://cplusplus.github.io/CWG/issues/3050.html">3050</a></td> + <td>[<a href="https://wg21.link/dcl.attr.deprecated">dcl.attr.deprecated</a>]</td> <td>open</td> <td>[[deprecated]] for class template partial specializations</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3051"> <td><a href="https://cplusplus.github.io/CWG/issues/3051.html">3051</a></td> + <td>[<a href="https://wg21.link/class.mem.general">class.mem.general</a>]</td> <td>open</td> <td>Missing specification for types of member subobjects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3052"> <td><a href="https://cplusplus.github.io/CWG/issues/3052.html">3052</a></td> + <td>[<a href="https://wg21.link/stmt.return">stmt.return</a>]</td> <td>open</td> <td>Unclear handling of checks on discarded <TT>return</TT> statements</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3053"> <td><a href="https://cplusplus.github.io/CWG/issues/3053.html">3053</a></td> + <td>[<a href="https://wg21.link/cpp.replace.general">cpp.replace.general</a>]</td> <td>tentatively ready</td> <td>Allowing <TT>#undef likely</TT></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3054"> <td><a href="https://cplusplus.github.io/CWG/issues/3054.html">3054</a></td> + <td>[<a href="https://wg21.link/expr.call">expr.call</a>]</td> <td>open</td> <td>Use of default arguments depending on shape of <I>postfix-expression</I> in a function call</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3055"> <td><a href="https://cplusplus.github.io/CWG/issues/3055.html">3055</a></td> + <td>[<a href="https://wg21.link/over.call.object">over.call.object</a>]</td> <td>open</td> <td>Misleading body for surrogate call function</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3056"> <td><a href="https://cplusplus.github.io/CWG/issues/3056.html">3056</a></td> + <td>[<a href="https://wg21.link/expr.prim.req.type">expr.prim.req.type</a>]</td> <td>open</td> <td>Missing semicolons in grammar for <I>type-requirement</I></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3057"> <td><a href="https://cplusplus.github.io/CWG/issues/3057.html">3057</a></td> + <td>[<a href="https://wg21.link/over.ics.ref">over.ics.ref</a>]</td> <td>open</td> <td>Ranking of derived-to-base conversions should ignore reference binding</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3058"> <td><a href="https://cplusplus.github.io/CWG/issues/3058.html">3058</a></td> + <td>[<a href="https://wg21.link/basic.lookup.general">basic.lookup.general</a>]</td> <td>open</td> <td>"Program point" is not defined</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3059"> <td><a href="https://cplusplus.github.io/CWG/issues/3059.html">3059</a></td> + <td>[<a href="https://wg21.link/expr.const">expr.const</a>]</td> <td>open</td> <td><TT>throw;</TT> in constant expressions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3060"> <td><a href="https://cplusplus.github.io/CWG/issues/3060.html">3060</a></td> + <td>[<a href="https://wg21.link/basic.start.main">basic.start.main</a>]</td> <td>open</td> <td>Change in behavior for <TT>noexcept</TT> <TT>main</TT></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3061"> <td><a href="https://cplusplus.github.io/CWG/issues/3061.html">3061</a></td> + <td>[<a href="https://wg21.link/stmt.expand">stmt.expand</a>]</td> <td>tentatively ready</td> <td>Trailing comma in an <I>expansion-init-list</I></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3062"> <td><a href="https://cplusplus.github.io/CWG/issues/3062.html">3062</a></td> + <td>[<a href="https://wg21.link/dcl.fct.default">dcl.fct.default</a>]</td> <td>open</td> <td>Overlapping specification of default template arguments</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3063"> <td><a href="https://cplusplus.github.io/CWG/issues/3063.html">3063</a></td> + <td>[<a href="https://wg21.link/class.temporary">class.temporary</a>]</td> <td>open</td> <td>Lifetime extension of temporaries past function return</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3064"> <td><a href="https://cplusplus.github.io/CWG/issues/3064.html">3064</a></td> + <td>[<a href="https://wg21.link/basic.life">basic.life</a>]</td> <td>open</td> <td>Mishandling of placement-new in lifetime rules</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3065"> <td><a href="https://cplusplus.github.io/CWG/issues/3065.html">3065</a></td> + <td>[<a href="https://wg21.link/basic.types.general">basic.types.general</a>]</td> <td>open</td> <td>Reachability and completeness of types</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3066"> <td><a href="https://cplusplus.github.io/CWG/issues/3066.html">3066</a></td> + <td>[<a href="https://wg21.link/expr.prim.id.qual">expr.prim.id.qual</a>]</td> <td>tentatively ready</td> <td>Declarative <I>nested-name-specifier</I> in explicit instantiation</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3067"> <td><a href="https://cplusplus.github.io/CWG/issues/3067.html">3067</a></td> + <td>[<a href="https://wg21.link/conv.array">conv.array</a>]</td> <td>open</td> <td>Array-to-pointer conversion with object type mismatch</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3068"> <td><a href="https://cplusplus.github.io/CWG/issues/3068.html">3068</a></td> + <td>[<a href="https://wg21.link/class.access.general">class.access.general</a>]</td> <td>open</td> <td>Access checking in friends involving <I>qualified-id</I>s</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3069"> <td><a href="https://cplusplus.github.io/CWG/issues/3069.html">3069</a></td> + <td>[<a href="https://wg21.link/temp.constr.normal">temp.constr.normal</a>]</td> <td>open</td> <td>Reference to wrong placeholder</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3070"> <td><a href="https://cplusplus.github.io/CWG/issues/3070.html">3070</a></td> + <td>[<a href="https://wg21.link/class.copy.assign">class.copy.assign</a>]</td> <td>open</td> <td>Trivial assignment can skip member subobjects</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3071"> <td><a href="https://cplusplus.github.io/CWG/issues/3071.html">3071</a></td> + <td>[<a href="https://wg21.link/dcl.struct.bind">dcl.struct.bind</a>]</td> <td>open</td> <td>Negative <TT>tuple_size</TT> in structured bindings</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3072"> <td><a href="https://cplusplus.github.io/CWG/issues/3072.html">3072</a></td> + <td>[<a href="https://wg21.link/temp.deduct.general">temp.deduct.general</a>]</td> <td>open</td> <td>Incorrect examples for lambda SFINAE</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3073"> <td><a href="https://cplusplus.github.io/CWG/issues/3073.html">3073</a></td> + <td>[<a href="https://wg21.link/over.match.ref">over.match.ref</a>]</td> <td>open</td> <td>Dependence of <I>R</I> on <TT>T2</TT> is unclear</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3074"> <td><a href="https://cplusplus.github.io/CWG/issues/3074.html">3074</a></td> + <td>[<a href="https://wg21.link/cpp.module">cpp.module</a>]</td> <td>tentatively ready</td> <td>Redundant ill-formedness for module macros</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3075"> <td><a href="https://cplusplus.github.io/CWG/issues/3075.html">3075</a></td> + <td>[<a href="https://wg21.link/cpp.import">cpp.import</a>]</td> <td>tentatively ready</td> <td>Unclear matching of import directive</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3076"> <td><a href="https://cplusplus.github.io/CWG/issues/3076.html">3076</a></td> + <td>[<a href="https://wg21.link/cpp.include">cpp.include</a>]</td> <td>tentatively ready</td> <td>Remove unnecessary IFNDR for malformed <I>header-name-token</I>s</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3077"> <td><a href="https://cplusplus.github.io/CWG/issues/3077.html">3077</a></td> + <td>[<a href="https://wg21.link/cpp.pre">cpp.pre</a>]</td> <td>tentatively ready</td> <td>Undesirable formation of <TT>import</TT> directive with <I>string-literal</I></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3078"> <td><a href="https://cplusplus.github.io/CWG/issues/3078.html">3078</a></td> + <td>[<a href="https://wg21.link/cpp.include">cpp.include</a>]</td> <td>review</td> <td>Different treatment of <TT>#include</TT> <I>pp-tokens</I> and <I>header-name-tokens</I></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3079"> <td><a href="https://cplusplus.github.io/CWG/issues/3079.html">3079</a></td> + <td>[<a href="https://wg21.link/class.union.anon">class.union.anon</a>]</td> <td>open</td> <td>Allow <I>empty-declaration</I>s in anonymous unions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3080"> <td><a href="https://cplusplus.github.io/CWG/issues/3080.html">3080</a></td> + <td>[<a href="https://wg21.link/temp.arg.template">temp.arg.template</a>]</td> <td>tentatively ready</td> <td>Clarify kinds of permitted template template arguments</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3081"> <td><a href="https://cplusplus.github.io/CWG/issues/3081.html">3081</a></td> + <td>[<a href="https://wg21.link/expr.ref">expr.ref</a>]</td> <td>review</td> <td>Require glvalue when splicing direct base class relationship</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3082"> <td><a href="https://cplusplus.github.io/CWG/issues/3082.html">3082</a></td> + <td>[<a href="https://wg21.link/expr.reinterpret.cast">expr.reinterpret.cast</a>]</td> <td>tentatively ready</td> <td>Allow for call-compatible function types in <TT>reinterpret_cast</TT></td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3083"> <td><a href="https://cplusplus.github.io/CWG/issues/3083.html">3083</a></td> + <td>[<a href="https://wg21.link/stmt.pre">stmt.pre</a>]</td> <td>tentatively ready</td> <td>Remove redundant restrictions on class and enum definitions</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3084"> <td><a href="https://cplusplus.github.io/CWG/issues/3084.html">3084</a></td> + <td>[<a href="https://wg21.link/stmt.cont">stmt.cont</a>]</td> <td>tentatively ready</td> <td><I>compound-statement</I>s inside <I>iteration-statement</I>s</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3085"> <td><a href="https://cplusplus.github.io/CWG/issues/3085.html">3085</a></td> + <td>[<a href="https://wg21.link/stmt.pre">stmt.pre</a>]</td> <td>tentatively ready</td> <td>Apply restriction inside for-range-declaration</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3086"> <td><a href="https://cplusplus.github.io/CWG/issues/3086.html">3086</a></td> + <td>[<a href="https://wg21.link/cpp.pragma.op">cpp.pragma.op</a>]</td> <td>tentatively ready</td> <td>Destringizing should consider all sorts of encoding-prefixes</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3087"> <td><a href="https://cplusplus.github.io/CWG/issues/3087.html">3087</a></td> + <td>[<a href="https://wg21.link/cpp.pragma.op">cpp.pragma.op</a>]</td> <td>open</td> <td>Destringizing for raw string literals</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3088"> <td><a href="https://cplusplus.github.io/CWG/issues/3088.html">3088</a></td> + <td>[<a href="https://wg21.link/cpp.replace.general">cpp.replace.general</a>]</td> <td>open</td> <td>Clarify macro treatment of identifiers with special meaning</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3089"> <td><a href="https://cplusplus.github.io/CWG/issues/3089.html">3089</a></td> + <td>[<a href="https://wg21.link/dcl.init.general">dcl.init.general</a>]</td> <td>tentatively ready</td> <td>const-default-constructible improperly handles std::meta::info</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3090"> <td><a href="https://cplusplus.github.io/CWG/issues/3090.html">3090</a></td> + <td>[<a href="https://wg21.link/module.interface">module.interface</a>]</td> <td>tentatively ready</td> <td>Internal linkage from header units</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3091"> <td><a href="https://cplusplus.github.io/CWG/issues/3091.html">3091</a></td> + <td>[<a href="https://wg21.link/basic.link">basic.link</a>]</td> <td>review</td> <td>Linking of translation units as sequences of tokens</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3092"> <td><a href="https://cplusplus.github.io/CWG/issues/3092.html">3092</a></td> + <td>[<a href="https://wg21.link/dcl.attr.annotation">dcl.attr.annotation</a>]</td> <td>tentatively ready</td> <td><I>base-specifier</I>s are not "declared"</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3093"> <td><a href="https://cplusplus.github.io/CWG/issues/3093.html">3093</a></td> + <td>[<a href="https://wg21.link/expr.prim.splice">expr.prim.splice</a>]</td> <td>open</td> <td>Missing integration of direct base class relationships</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3094"> <td><a href="https://cplusplus.github.io/CWG/issues/3094.html">3094</a></td> + <td>[<a href="https://wg21.link/lex.phases">lex.phases</a>]</td> <td>review</td> <td>Rework phases for string literal concatenation and token formation</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3095"> <td><a href="https://cplusplus.github.io/CWG/issues/3095.html">3095</a></td> + <td>[<a href="https://wg21.link/temp.dep.expr">temp.dep.expr</a>]</td> <td>open</td> <td>Type-dependent packs that are not structured binding packs</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3096"> <td><a href="https://cplusplus.github.io/CWG/issues/3096.html">3096</a></td> + <td>[<a href="https://wg21.link/temp.dep.constexpr">temp.dep.constexpr</a>]</td> <td>open</td> <td>Value-dependence of size of structured binding pack with non-dependent initializer</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3097"> <td><a href="https://cplusplus.github.io/CWG/issues/3097.html">3097</a></td> + <td>[<a href="https://wg21.link/basic.scope.scope">basic.scope.scope</a>]</td> <td>tentatively ready</td> <td>Lambda expression introduces a scope</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3098"> <td><a href="https://cplusplus.github.io/CWG/issues/3098.html">3098</a></td> + <td>[<a href="https://wg21.link/temp.names">temp.names</a>]</td> <td>tentatively ready</td> <td>Remove redundancy "names or designates"</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3099"> <td><a href="https://cplusplus.github.io/CWG/issues/3099.html">3099</a></td> + <td>[<a href="https://wg21.link/temp.inst">temp.inst</a>]</td> <td>open</td> <td>Instantiation of type aliases from alias templates is unspecified</td> <td align="center">Not resolved</td> </tr> <tr class="open" id="3100"> <td><a href="https://cplusplus.github.io/CWG/issues/3100.html">3100</a></td> + <td>[<a href="https://wg21.link/basic.start.term">basic.start.term</a>]</td> <td>open</td> <td>Destruction order for objects with static storage duration</td> <td align="center">Not resolved</td> diff --git a/clang/www/make_cxx_dr_status b/clang/www/make_cxx_dr_status index 485a9a5..3ba12e1 100755 --- a/clang/www/make_cxx_dr_status +++ b/clang/www/make_cxx_dr_status @@ -10,26 +10,36 @@ output = os.path.join(clang_www_dir, 'cxx_dr_status.html') dr_test_dir = os.path.join(clang_www_dir, '../test/CXX/drs') class DR: - def __init__(self, section, issue, url, status, title): - self.section, self.issue, self.url, self.status, self.title = \ - section, issue, url, status, title + def __init__(self, *, section_number, section_name, section_link, number, url, status, liaison, title): + self.section_number, self.section_name, self.section_link, self.number, self.url, self.status, self.liaison, self.title = \ + section_number, section_name, section_link, number, url, status, liaison, title def __repr__(self): - return '%s (%s): %s' % (self.issue, self.status, self.title) - -def parse(dr): - try: - section, issue_link, status, liaison, title = [ - col.split('>', 1)[1].split('</TD>')[0] - for col in dr.split('</TR>', 1)[0].split('<TD')[1:] - ] - except Exception as ex: - print(f"Parse error: {ex}\n{dr}", file=sys.stderr) - sys.exit(1) - _, url, issue = issue_link.split('"', 2) - url = url.strip() - issue = int(issue.split('>', 1)[1].split('<', 1)[0]) - title = title.replace('<issue_title>', '').replace('</issue_title>', '').replace('\r\n', '\n').strip() - return DR(section, issue, url, status, title) + return '%s (%s): %s' % (self.number, self.status, self.title) + + pattern = re.compile(''' +<TD.*>(?P<section_number>.*) <A href="(?P<section_link>.*)">(?P<section_name>.*)</A> +</TD> +<TD.*><A HREF="(?P<url>.*)">(?P<number>.*)</A></TD> +<TD.*>(?P<status>.*)</TD> +<TD.*>(?P<liaison>.*)</TD> +<TD.*><issue_title>(?P<title>[\\w\\W]*)</issue_title></TD> +</TR>''') + + @classmethod + def parse_from_html(cls, html_string): + match = cls.pattern.match(html_string) + if match is None: + print(f"Parse error: {html_string}", file=sys.stderr) + exit(1) + return cls( + section_number=match.group('section_number'), + section_name=match.group('section_name'), + section_link=match.group('section_link'), + number=int(match.group('number')), + url=match.group('url'), + status=match.group('status'), + liaison=match.group('liaison'), + title=match.group('title').replace('\n', ' ').strip()) def collect_tests(): status_re = re.compile(r'\bcwg([0-9]+): (.*)') @@ -68,8 +78,8 @@ def get_issues(path): print(ex, file=sys.stderr) sys.exit(1) - return sorted((parse(dr) for dr in buffer.split('<TR>')[2:]), - key = lambda dr: dr.issue) + return sorted((DR.parse_from_html(dr) for dr in buffer.split('<TR>')[2:]), + key = lambda dr: dr.number) issue_list_path = None @@ -127,9 +137,10 @@ out_html.append('''\ <p>This page tracks which C++ defect reports are implemented within Clang.</p> -<table width="689" border="1" cellspacing="0"> +<table width="892" border="1" cellspacing="0"> <tr> <th>Number</th> + <th>Section</th> <th>Status</th> <th>Issue title</th> <th>Available in Clang?</th> @@ -149,7 +160,7 @@ def availability(issue): unresolved_status = unresolved_status_match.group(1) proposed_resolution_match = re.search(r' (open|drafting|review|tentatively ready|ready) (\d{4}-\d{2}(?:-\d{2})?|P\d{4}R\d+)$', status) if proposed_resolution_match is None: - raise AvailabilityError('error: issue {}: \'{}\' status should be followed by a paper number (P1234R5) or proposed resolution in YYYY-MM-DD format'.format(dr.issue, unresolved_status)) + raise AvailabilityError('error: issue {}: \'{}\' status should be followed by a paper number (P1234R5) or proposed resolution in YYYY-MM-DD format'.format(dr.number, unresolved_status)) proposed_resolution = proposed_resolution_match.group(2) status = status[:-1-len(proposed_resolution)] status = status[:-1-len(unresolved_status)] @@ -236,7 +247,7 @@ def availability(issue): avail = 'Duplicate of <a href="#%s">%s</a>' % (dup, dup) _, avail_style, _, _ = availability(dup) else: - raise AvailabilityError('error: unknown status %s for issue %s' % (status, dr.issue)) + raise AvailabilityError('error: unknown status %s for issue %s' % (status, dr.number)) return (avail + avail_suffix, avail_style, unresolved_status, details) count = {} @@ -254,7 +265,7 @@ for dr in drs: elif dr.status in ('open', 'drafting', 'review', 'tentatively ready', 'ready'): row_style = ' class="open"' try: - avail, avail_style, unresolved_status, details = availability(dr.issue) + avail, avail_style, unresolved_status, details = availability(dr.number) except AvailabilityError as e: availability_error_occurred = True print(e.args[0]) @@ -267,12 +278,12 @@ for dr in drs: if unresolved_status != dr.status: availability_error_occurred = True print("error: issue %s is marked '%s', which differs from CWG index status '%s'" \ - % (dr.issue, unresolved_status, dr.status)) + % (dr.number, unresolved_status, dr.status)) continue else: row_style = '' try: - avail, avail_style, unresolved_status, details = availability(dr.issue) + avail, avail_style, unresolved_status, details = availability(dr.number) except AvailabilityError as e: availability_error_occurred = True print(e.args[0]) @@ -281,7 +292,7 @@ for dr in drs: if unresolved_status: availability_error_occurred = True print("error: issue %s is marked '%s', even though it is resolved in CWG index" \ - % (dr.issue, unresolved_status)) + % (dr.number, unresolved_status)) continue if not avail.startswith('Sup') and not avail.startswith('Dup'): @@ -297,8 +308,9 @@ for dr in drs: {details} </details>''' out_html.append(f''' - <tr{row_style} id="{dr.issue}"> - <td><a href="https://cplusplus.github.io/CWG/issues/{dr.issue}.html">{dr.issue}</a></td> + <tr{row_style} id="{dr.number}"> + <td><a href="https://cplusplus.github.io/CWG/issues/{dr.number}.html">{dr.number}</a></td> + <td>[<a href="{dr.section_link}">{dr.section_name}</a>]</td> <td>{dr.status}</td> <td>{dr.title}</td> <td{avail_style} align="center">{avail}</td> |