Merged main:50c298fd174f into amd-gfx:ed8d3fbeeabb

Local branch amd-gfx ed8d3fb Merged main:cf1bde33423d into amd-gfx:af24aa3aae84
Remote branch main 50c298f [CVP] Regenerate test checks (NFC)

Author: SC llvm team

.github/workflows/libcxx-build-and-test.yaml

@@ -43,6 +43,7 @@ env:
 
 jobs:
   stage1:
+    if: github.repository_owner == 'llvm'
     runs-on:
       group: libcxx-runners-8
     continue-on-error: false
@@ -81,6 +82,7 @@ jobs:
             **/CMakeOutput.log
             **/crash_diagnostics/*
   stage2:
+    if: github.repository_owner == 'llvm'
     runs-on:
       group: libcxx-runners-8
     needs: [ stage1 ]
@@ -130,6 +132,7 @@ jobs:
             **/CMakeOutput.log
             **/crash_diagnostics/*
   stage3:
+    if: github.repository_owner == 'llvm'
     needs: [ stage1, stage2 ]
     continue-on-error: false
     strategy:

clang/docs/ReleaseNotes.rst

@@ -225,8 +225,8 @@ Non-comprehensive list of changes in this release
   determined at runtime.
 * The ``__datasizeof`` keyword has been added. It is similar to ``sizeof``
   except that it returns the size of a type ignoring tail padding.
-* ``__builtin_classify_type()`` now classifies ``_BitInt`` values as the return value ``18``,
-  to match GCC 14's behavior.
+* ``__builtin_classify_type()`` now classifies ``_BitInt`` values as the return value ``18``
+  and vector types as return value ``19``, to match GCC 14's behavior.
 
 New Compiler Flags
 ------------------

clang/include/clang/Basic/AttrDocs.td

@@ -7585,7 +7585,7 @@ def CoroLifetimeBoundDoc : Documentation {
   let Category = DocCatDecl;
   let Content = [{
 The ``[[clang::coro_lifetimebound]]`` is a class attribute which can be applied
-to a `coroutine return type (`CRT`_) (i.e.
+to a coroutine return type (`CRT`_) (i.e.
 it should also be annotated with ``[[clang::coro_return_type]]``).
 
 All parameters of a function are considered to be lifetime bound. See `documentation`_

clang/lib/AST/ASTImporter.cpp

@@ -3513,6 +3513,14 @@ class IsTypeDeclaredInsideVisitor
     return {};
   }
 
+  std::optional<bool>
+  VisitSubstTemplateTypeParmType(const SubstTemplateTypeParmType *T) {
+    // The "associated declaration" can be the same as ParentDC.
+    if (isAncestorDeclContextOf(ParentDC, T->getAssociatedDecl()))
+      return true;
+    return {};
+  }
+
   std::optional<bool> VisitConstantArrayType(const ConstantArrayType *T) {
     if (T->getSizeExpr() && isAncestorDeclContextOf(ParentDC, T->getSizeExpr()))
       return true;
@@ -3573,6 +3581,8 @@ class IsTypeDeclaredInsideVisitor
 };
 } // namespace
 
+/// This function checks if the function has 'auto' return type that contains
+/// a reference (in any way) to a declaration inside the same function.
 bool ASTNodeImporter::hasAutoReturnTypeDeclaredInside(FunctionDecl *D) {
   QualType FromTy = D->getType();
   const auto *FromFPT = FromTy->getAs<FunctionProtoType>();

clang/lib/AST/ExprConstShared.h

@@ -49,7 +49,8 @@ enum class GCCTypeClass {
   // literals.
   // Lang = 16,
   // OpaqueType = 17,
-  BitInt = 18
+  BitInt = 18,
+  Vector = 19
 };
 
 GCCTypeClass EvaluateBuiltinClassifyType(QualType T,

clang/lib/AST/ExprConstant.cpp

@@ -11615,16 +11615,18 @@ GCCTypeClass EvaluateBuiltinClassifyType(QualType T,
     return EvaluateBuiltinClassifyType(
         CanTy->castAs<AtomicType>()->getValueType(), LangOpts);
 
-  case Type::BlockPointer:
   case Type::Vector:
   case Type::ExtVector:
+    return GCCTypeClass::Vector;
+
+  case Type::BlockPointer:
   case Type::ConstantMatrix:
   case Type::ObjCObject:
   case Type::ObjCInterface:
   case Type::ObjCObjectPointer:
   case Type::Pipe:
-    // GCC classifies vectors as None. We follow its lead and classify all
-    // other types that don't fit into the regular classification the same way.
+    // Classify all other types that don't fit into the regular
+    // classification the same way.
     return GCCTypeClass::None;
 
   case Type::BitInt:

clang/test/Sema/builtin-classify-type.c

@@ -13,7 +13,7 @@ enum gcc_type_class {
   record_type_class, union_type_class,
   array_type_class, string_type_class,
   lang_type_class, opaque_type_class,
-  bitint_type_class
+  bitint_type_class, vector_type_class
 };
 
 void foo(void) {
@@ -67,8 +67,8 @@ void foo(void) {
   int a11[__builtin_classify_type(arr) == pointer_type_class ? 1 : -1];
   int a12[__builtin_classify_type("abc") == pointer_type_class ? 1 : -1];
   int a13[__builtin_classify_type(block) == no_type_class ? 1 : -1];
-  int a14[__builtin_classify_type(vec) == no_type_class ? 1 : -1];
-  int a15[__builtin_classify_type(evec) == no_type_class ? 1 : -1];
+  int a14[__builtin_classify_type(vec) == vector_type_class ? 1 : -1];
+  int a15[__builtin_classify_type(evec) == vector_type_class ? 1 : -1];
   int a16[__builtin_classify_type(atomic_i) == integer_type_class ? 1 : -1];
   int a17[__builtin_classify_type(atomic_d) == real_type_class ? 1 : -1];
   int a18[__builtin_classify_type(complex_i) == complex_type_class ? 1 : -1];

clang/test/SemaCXX/builtin-classify-type.cpp

@@ -13,7 +13,7 @@ enum gcc_type_class {
   record_type_class, union_type_class,
   array_type_class, string_type_class,
   lang_type_class, opaque_type_class,
-  bitint_type_class
+  bitint_type_class, vector_type_class
 };
 
 class cl {
@@ -62,8 +62,8 @@ void foo() {
   int a14[__builtin_classify_type(arr) == pointer_type_class ? 1 : -1];
   int a15[__builtin_classify_type("abc") == pointer_type_class ? 1 : -1];
   int a16[__builtin_classify_type(block) == no_type_class ? 1 : -1];
-  int a17[__builtin_classify_type(vec) == no_type_class ? 1 : -1];
-  int a18[__builtin_classify_type(evec) == no_type_class ? 1 : -1];
+  int a17[__builtin_classify_type(vec) == vector_type_class ? 1 : -1];
+  int a18[__builtin_classify_type(evec) == vector_type_class ? 1 : -1];
   int a19[__builtin_classify_type(atomic_i) == integer_type_class ? 1 : -1];
   int a20[__builtin_classify_type(atomic_d) == real_type_class ? 1 : -1];
   int a21[__builtin_classify_type(complex_i) == complex_type_class ? 1 : -1];

clang/unittests/AST/ASTImporterTest.cpp

@@ -6790,10 +6790,13 @@ TEST_P(ASTImporterOptionSpecificTestBase,
 }
 
 struct ImportAutoFunctions : ASTImporterOptionSpecificTestBase {
-  void testImport(llvm::StringRef Code, clang::TestLanguage Lang = Lang_CXX14) {
+  void testImport(llvm::StringRef Code, clang::TestLanguage Lang = Lang_CXX14,
+                  bool FindLast = false) {
     Decl *FromTU = getTuDecl(Code, Lang, "input0.cc");
-    FunctionDecl *From = FirstDeclMatcher<FunctionDecl>().match(
-        FromTU, functionDecl(hasName("foo")));
+    FunctionDecl *From = FindLast ? LastDeclMatcher<FunctionDecl>().match(
+                                        FromTU, functionDecl(hasName("foo")))
+                                  : FirstDeclMatcher<FunctionDecl>().match(
+                                        FromTU, functionDecl(hasName("foo")));
 
     FunctionDecl *To = Import(From, Lang);
     EXPECT_TRUE(To);
@@ -7232,6 +7235,20 @@ TEST_P(ImportAutoFunctions, ReturnWithTypeInSwitch) {
       Lang_CXX17);
 }
 
+TEST_P(ImportAutoFunctions, ReturnWithAutoTemplateType) {
+  testImport(
+      R"(
+      template<class T>
+      struct S {};
+      template<class T>
+      auto foo() {
+        return S<T>{};
+      }
+      auto a = foo<int>();
+      )",
+      Lang_CXX14, /*FindLast=*/true);
+}
+
 struct ImportSourceLocations : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportSourceLocations, PreserveFileIDTreeStructure) {

libc/src/__support/FPUtil/FloatProperties.h

@@ -218,24 +218,6 @@ template <> struct FloatProperties<float128> {
 };
 #endif // LIBC_COMPILER_HAS_FLOAT128
 
-// Define the float type corresponding to the BitsType.
-template <typename BitsType> struct FloatType;
-
-template <> struct FloatType<uint32_t> {
-  static_assert(sizeof(uint32_t) == sizeof(float),
-                "Unexpected size of 'float' type.");
-  typedef float Type;
-};
-
-template <> struct FloatType<uint64_t> {
-  static_assert(sizeof(uint64_t) == sizeof(double),
-                "Unexpected size of 'double' type.");
-  typedef double Type;
-};
-
-template <typename BitsType>
-using FloatTypeT = typename FloatType<BitsType>::Type;
-
 } // namespace fputil
 } // namespace LIBC_NAMESPACE