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
 

llvm/include/llvm-c/Orc.h

@@ -346,7 +346,7 @@ typedef struct LLVMOrcOpaqueLookupState *LLVMOrcLookupStateRef;
  * into.
  *
  * The JDLookupFlags argument can be inspected to determine whether the original
- * lookup included non-exported symobls.
+ * lookup included non-exported symbols.
  *
  * Finally, the LookupSet argument contains the set of symbols that could not
  * be found in JD already (the set of generation candidates).

llvm/include/llvm/Analysis/VecFuncs.def

@@ -492,6 +492,7 @@ TLI_DEFINE_VECFUNC( "exp2", "_ZGVnN2v_exp2", FIXED(2), "_ZGV_LLVM_N2v")
 TLI_DEFINE_VECFUNC( "llvm.exp2.f64", "_ZGVnN2v_exp2", FIXED(2), "_ZGV_LLVM_N2v")
 
 TLI_DEFINE_VECFUNC( "exp10", "_ZGVnN2v_exp10", FIXED(2), "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC( "llvm.exp10.f64", "_ZGVnN2v_exp10", FIXED(2), "_ZGV_LLVM_N2v")
 
 TLI_DEFINE_VECFUNC( "lgamma", "_ZGVnN2v_lgamma", FIXED(2), "_ZGV_LLVM_N2v")
 
@@ -544,6 +545,7 @@ TLI_DEFINE_VECFUNC( "exp2f", "_ZGVnN4v_exp2f", FIXED(4), "_ZGV_LLVM_N4v")
 TLI_DEFINE_VECFUNC( "llvm.exp2.f32", "_ZGVnN4v_exp2f", FIXED(4), "_ZGV_LLVM_N4v")
 
 TLI_DEFINE_VECFUNC( "exp10f", "_ZGVnN4v_exp10f", FIXED(4), "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC( "llvm.exp10.f32", "_ZGVnN4v_exp10f", FIXED(4), "_ZGV_LLVM_N4v")
 
 TLI_DEFINE_VECFUNC( "lgammaf", "_ZGVnN4v_lgammaf", FIXED(4), "_ZGV_LLVM_N4v")
 
@@ -609,6 +611,8 @@ TLI_DEFINE_VECFUNC("llvm.exp2.f32", "_ZGVsMxv_exp2f", SCALABLE(4), MASKED, "_ZGV
 
 TLI_DEFINE_VECFUNC("exp10", "_ZGVsMxv_exp10",  SCALABLE(2), MASKED, "_ZGVsMxv")
 TLI_DEFINE_VECFUNC("exp10f", "_ZGVsMxv_exp10f", SCALABLE(4), MASKED, "_ZGVsMxv")
+TLI_DEFINE_VECFUNC("llvm.exp10.f64", "_ZGVsMxv_exp10",  SCALABLE(2), MASKED, "_ZGVsMxv")
+TLI_DEFINE_VECFUNC("llvm.exp10.f32", "_ZGVsMxv_exp10f", SCALABLE(4), MASKED, "_ZGVsMxv")
 
 TLI_DEFINE_VECFUNC("fmod", "_ZGVsMxvv_fmod", SCALABLE(2), MASKED, "_ZGVsMxvv")
 TLI_DEFINE_VECFUNC("fmodf", "_ZGVsMxvv_fmodf", SCALABLE(4), MASKED, "_ZGVsMxvv")
@@ -753,6 +757,11 @@ TLI_DEFINE_VECFUNC("exp10f", "armpl_vexp10q_f32", FIXED(4), NOMASK, "_ZGV_LLVM_N
 TLI_DEFINE_VECFUNC("exp10", "armpl_svexp10_f64_x",  SCALABLE(2), MASKED, "_ZGVsMxv")
 TLI_DEFINE_VECFUNC("exp10f", "armpl_svexp10_f32_x", SCALABLE(4), MASKED, "_ZGVsMxv")
 
+TLI_DEFINE_VECFUNC("llvm.exp10.f64", "armpl_vexp10q_f64", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
+TLI_DEFINE_VECFUNC("llvm.exp10.f32", "armpl_vexp10q_f32", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
+TLI_DEFINE_VECFUNC("llvm.exp10.f64", "armpl_svexp10_f64_x",  SCALABLE(2), MASKED, "_ZGVsMxv")
+TLI_DEFINE_VECFUNC("llvm.exp10.f32", "armpl_svexp10_f32_x", SCALABLE(4), MASKED, "_ZGVsMxv")
+
 TLI_DEFINE_VECFUNC("expm1", "armpl_vexpm1q_f64", FIXED(2), NOMASK, "_ZGV_LLVM_N2v")
 TLI_DEFINE_VECFUNC("expm1f", "armpl_vexpm1q_f32", FIXED(4), NOMASK, "_ZGV_LLVM_N4v")
 TLI_DEFINE_VECFUNC("expm1", "armpl_svexpm1_f64_x",  SCALABLE(2), MASKED, "_ZGVsMxv")

llvm/include/llvm/CodeGen/MIRFormatter.h

@@ -14,6 +14,7 @@
 #define LLVM_CODEGEN_MIRFORMATTER_H
 
 #include "llvm/CodeGen/PseudoSourceValue.h"
+#include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cstdint>
 #include <optional>
@@ -22,7 +23,10 @@ namespace llvm {
 
 class MachineFunction;
 class MachineInstr;
+class ModuleSlotTracker;
 struct PerFunctionMIParsingState;
+class Twine;
+class Value;
 
 /// MIRFormater - Interface to format MIR operand based on target
 class MIRFormatter {

llvm/include/llvm/CodeGen/MIRParser/MIParser.h

@@ -17,8 +17,10 @@
 #include "llvm/ADT/StringMap.h"
 #include "llvm/CodeGen/MachineMemOperand.h"
 #include "llvm/CodeGen/Register.h"
+#include "llvm/IR/TrackingMDRef.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/SMLoc.h"
+#include <map>
 #include <utility>
 
 namespace llvm {

llvm/include/llvm/CodeGen/MachineMemOperand.h

@@ -20,6 +20,8 @@
 #include "llvm/CodeGen/LowLevelType.h"
 #include "llvm/CodeGen/PseudoSourceValue.h"
 #include "llvm/IR/DerivedTypes.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/IR/Value.h" // PointerLikeTypeTraits<Value*>
 #include "llvm/Support/AtomicOrdering.h"
 #include "llvm/Support/DataTypes.h"

llvm/include/llvm/CodeGen/ModuloSchedule.h

@@ -65,6 +65,7 @@
 #include "llvm/CodeGen/TargetInstrInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include <deque>
+#include <map>
 #include <vector>
 
 namespace llvm {

llvm/include/llvm/CodeGen/TargetFrameLowering.h

@@ -13,6 +13,7 @@
 #ifndef LLVM_CODEGEN_TARGETFRAMELOWERING_H
 #define LLVM_CODEGEN_TARGETFRAMELOWERING_H
 
+#include "llvm/ADT/BitVector.h"
 #include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/Support/TypeSize.h"
 #include <vector>

llvm/include/llvm/Config/llvm-config.h.cmake

@@ -16,7 +16,7 @@
 
 /* Indicate that this is LLVM compiled from the amd-gfx branch. */
 #define LLVM_HAVE_BRANCH_AMD_GFX
-#define LLVM_MAIN_REVISION 481650
+#define LLVM_MAIN_REVISION 481663
 
 /* Define if LLVM_ENABLE_DUMP is enabled */
 #cmakedefine LLVM_ENABLE_DUMP

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

@@ -1862,7 +1862,7 @@ Error makeAlignmentError(llvm::orc::ExecutorAddr Loc, uint64_t Value, int N,
                          const Edge &E);
 
 /// Creates a new pointer block in the given section and returns an
-/// Anonymous symobl pointing to it.
+/// Anonymous symbol pointing to it.
 ///
 /// The pointer block will have the following default values:
 ///   alignment: PointerSize

llvm/include/llvm/ExecutionEngine/JITLink/aarch64.h

@@ -618,7 +618,7 @@ extern const char NullPointerContent[PointerSize];
 extern const char PointerJumpStubContent[12];
 
 /// Creates a new pointer block in the given section and returns an
-/// Anonymous symobl pointing to it.
+/// Anonymous symbol pointing to it.
 ///
 /// If InitialTarget is given then an Pointer64 relocation will be added to the
 /// block pointing at InitialTarget.

llvm/include/llvm/ExecutionEngine/JITLink/loongarch.h

@@ -280,7 +280,7 @@ inline ArrayRef<char> getStubBlockContent(LinkGraph &G) {
 }
 
 /// Creates a new pointer block in the given section and returns an
-/// Anonymous symobl pointing to it.
+/// Anonymous symbol pointing to it.
 ///
 /// If InitialTarget is given then an Pointer64 relocation will be added to the
 /// block pointing at InitialTarget.

llvm/lib/CodeGen/LiveDebugVariables.cpp

@@ -58,6 +58,7 @@
 #include <algorithm>
 #include <cassert>
 #include <iterator>
+#include <map>
 #include <memory>
 #include <optional>
 #include <utility>

llvm/lib/Target/AArch64/AArch64SIMDInstrOpt.cpp

@@ -50,6 +50,7 @@
 #include "llvm/MC/MCSchedule.h"
 #include "llvm/Pass.h"
 #include <unordered_map>
+#include <map>
 
 using namespace llvm;
 

llvm/lib/Target/AArch64/GISel/AArch64RegisterBankInfo.cpp

@@ -30,6 +30,7 @@
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/IntrinsicsAArch64.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/Threading.h"
 #include <algorithm>
 #include <cassert>
 

llvm/lib/Target/AMDGPU/SIRegisterInfo.h

@@ -14,6 +14,8 @@
 #ifndef LLVM_LIB_TARGET_AMDGPU_SIREGISTERINFO_H
 #define LLVM_LIB_TARGET_AMDGPU_SIREGISTERINFO_H
 
+#include "llvm/ADT/BitVector.h"
+
 #define GET_REGINFO_HEADER
 #include "AMDGPUGenRegisterInfo.inc"
 

llvm/lib/Target/BPF/BPFAbstractMemberAccess.cpp

@@ -89,6 +89,7 @@
 #include "llvm/IR/Type.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
+#include "llvm/IR/ValueHandle.h"
 #include "llvm/Pass.h"
 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
 #include <stack>

llvm/lib/Target/Hexagon/HexagonExpandCondsets.cpp

@@ -115,6 +115,7 @@
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <iterator>
+#include <map>
 #include <set>
 #include <utility>