merge main into amd-staging

Change-Id: I7d02f649a5f7c28e3f8fab3bede9ad948d13d970

Author: Jenkins

bolt/lib/Profile/BoltAddressTranslation.cpp

@@ -304,7 +304,7 @@ std::error_code BoltAddressTranslation::parse(raw_ostream &OS, StringRef Buf) {
 
   StringRef Name = Buf.slice(Offset, Offset + NameSz);
   Offset = alignTo(Offset + NameSz, 4);
-  if (Name.substr(0, 4) != "BOLT")
+  if (!Name.starts_with("BOLT"))
     return make_error_code(llvm::errc::io_error);
 
   Error Err(Error::success());

clang-tools-extra/clang-query/QueryParser.cpp

@@ -144,13 +144,11 @@ QueryRef QueryParser::endQuery(QueryRef Q) {
   StringRef Extra = Line;
   StringRef ExtraTrimmed = Extra.ltrim(" \t\v\f\r");
 
-  if ((!ExtraTrimmed.empty() && ExtraTrimmed[0] == '\n') ||
-      (ExtraTrimmed.size() >= 2 && ExtraTrimmed[0] == '\r' &&
-       ExtraTrimmed[1] == '\n'))
+  if (ExtraTrimmed.starts_with('\n') || ExtraTrimmed.starts_with("\r\n"))
     Q->RemainingContent = Extra;
   else {
     StringRef TrailingWord = lexWord();
-    if (!TrailingWord.empty() && TrailingWord.front() == '#') {
+    if (TrailingWord.starts_with('#')) {
       Line = Line.drop_until([](char c) { return c == '\n'; });
       Line = Line.drop_while([](char c) { return c == '\n'; });
       return endQuery(Q);

clang/lib/AST/Interp/ByteCodeExprGen.cpp

@@ -1834,6 +1834,9 @@ bool ByteCodeExprGen<Emitter>::VisitCompoundAssignOperator(
   std::optional<PrimType> RT = classify(RHS->getType());
   std::optional<PrimType> ResultT = classify(E->getType());
 
+  if (!Ctx.getLangOpts().CPlusPlus14)
+    return this->visit(RHS) && this->visit(LHS) && this->emitError(E);
+
   if (!LT || !RT || !ResultT || !LHSComputationT)
     return false;
 
@@ -3827,6 +3830,21 @@ bool ByteCodeExprGen<Emitter>::VisitComplexUnaryOperator(
     // we sometimes have to do the lvalue-to-rvalue conversion here manually.
     return this->emitArrayElemPop(classifyPrim(E->getType()), 1, E);
 
+  case UO_Not: // ~x
+    if (!this->visit(SubExpr))
+      return false;
+    // Negate the imaginary component.
+    if (!this->emitArrayElem(ElemT, 1, E))
+      return false;
+    if (!this->emitNeg(ElemT, E))
+      return false;
+    if (!this->emitInitElem(ElemT, 1, E))
+      return false;
+    return DiscardResult ? this->emitPopPtr(E) : true;
+
+  case UO_Extension:
+    return this->delegate(SubExpr);
+
   default:
     return this->emitInvalid(E);
   }

clang/test/AST/Interp/complex.cpp

@@ -115,6 +115,11 @@ static_assert(__imag(Doubles[2]) == 0.0, "");
 static_assert(__real(Doubles[3]) == 0.0, "");
 static_assert(__imag(Doubles[3]) == 0.0, "");
 
+static_assert(~(0.5 + 1.5j) == (0.5 + -1.5j), "");
+
+static_assert(__extension__ __imag(A) == 0, "");
+static_assert(__imag(__extension__ A) == 0, "");
+
 void func(void) {
   __complex__ int arr;
   _Complex int result;

clang/test/SemaCXX/for-range-examples.cpp

@@ -1,4 +1,5 @@
 // RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11
+// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++11 -fexperimental-new-constant-interpreter
 
 namespace value_range_detail {
   template<typename T>

clang/test/SemaCXX/integer-overflow.cpp

@@ -1,6 +1,10 @@
 // RUN: %clang_cc1 %s -verify -fsyntax-only -std=gnu++98 -triple x86_64-pc-linux-gnu
 // RUN: %clang_cc1 %s -verify -fsyntax-only -std=gnu++2a -triple x86_64-pc-linux-gnu
 
+// RUN: %clang_cc1 %s -verify -fsyntax-only -std=gnu++98 -triple x86_64-pc-linux-gnu -fexperimental-new-constant-interpreter
+// RUN: %clang_cc1 %s -verify -fsyntax-only -std=gnu++2a -triple x86_64-pc-linux-gnu -fexperimental-new-constant-interpreter
+
+
 typedef unsigned long long uint64_t;
 typedef unsigned int uint32_t;
 

clang/test/SemaTemplate/cwg2398.cpp

@@ -200,8 +200,120 @@ namespace consistency {
     template struct A<B<int>, B<int>, B<int>>;
     // new-error@-1 {{ambiguous partial specializations}}
   } // namespace t2
+  namespace t3 {
+    template<class T1, class T2, class T3> struct A;
+
+    template<template<class, class> class TT1,
+             class T1, class T2, class T3, class T4>
+    struct A<TT1<T1, T2>, TT1<T3, T4>, typename nondeduced<TT1<T1, T2>>::type> {};
+    // new-note@-1 {{partial specialization matches}}
+
+    template<template<class> class UU1,
+             class U1, class U2>
+    struct A<UU1<U1>, UU1<U2>, typename nondeduced<UU1<U1>>::type>;
+    // new-note@-1 {{partial specialization matches}}
+
+    template struct A<B<int>, B<int>, B<int>>;
+    // new-error@-1 {{ambiguous partial specializations}}
+  } // namespace t3
+  namespace t4 {
+    template<class T1, class T2, class T3> struct A;
+
+    template<template<class, class> class TT1,
+             class T1, class T2, class T3, class T4>
+    struct A<TT1<T1, T2>, TT1<T3, T4>, typename nondeduced<TT1<T1, T4>>::type> {};
+    // new-note@-1 {{partial specialization matches}}
+
+    template<template<class> class UU1,
+             class U1, class U2>
+    struct A<UU1<U1>, UU1<U2>, typename nondeduced<UU1<U1>>::type>;
+    // new-note@-1 {{partial specialization matches}}
+
+    template struct A<B<int>, B<int>, B<int>>;
+    // new-error@-1 {{ambiguous partial specializations}}
+  } // namespace t4
+  namespace t5 {
+    template<class T1, class T2> struct A;
+
+    template<template<class, class> class TT1,
+             class T1, class T2, class T3, class T4>
+    struct A<TT1<T1, T2>, TT1<T3, T4>> {};
+    // new-note@-1 {{partial specialization matches}}
+
+    template<template<class> class UU1,
+             class U1, class U2>
+    struct A<UU1<U1>, UU1<U2>>;
+    // new-note@-1 {{partial specialization matches}}
+
+    template struct A<B<int>, B<int>>;
+    // new-error@-1 {{ambiguous partial specializations}}
+  } // namespace t5
+  namespace t6 {
+    template<class T1, class T2> struct A;
+
+    template<template<class, class> class TT1,
+             class T1, class T2, class T3>
+    struct A<TT1<T1, T2>, TT1<T1, T3>> {};
+    // new-note@-1 {{partial specialization matches}}
+
+    template<template<class> class UU1,
+             class U1, class U2>
+    struct A<UU1<U1>, UU1<U2>>;
+    // new-note@-1 {{partial specialization matches}}
+
+    template struct A<B<int>, B<int>>;
+    // new-error@-1 {{ambiguous partial specializations}}
+  } // namespace t6
 } // namespace consistency
 
+namespace classes {
+  namespace canon {
+    template<class T, class U> struct A {};
+
+    template<template<class> class TT> auto f(TT<int> a) { return a; }
+    // old-note@-1 2{{template template argument has different template parameters}}
+    // new-note@-2 2{{substitution failure: too few template arguments}}
+
+    A<int, float> v1;
+    A<int, double> v2;
+
+    using X = decltype(f(v1));
+    // expected-error@-1 {{no matching function for call}}
+
+    using X = decltype(f(v2));
+    // expected-error@-1 {{no matching function for call}}
+  } // namespace canon
+  namespace expr {
+    template <class T1, int E1> struct A {
+      static constexpr auto val = E1;
+    };
+    template <template <class T3> class TT> void f(TT<int> v) {
+      // old-note@-1 {{template template argument has different template parameters}}
+      // new-note@-2 {{substitution failure: too few template arguments}}
+      static_assert(v.val == 3);
+    };
+    void test() {
+      f(A<int, 3>());
+      // expected-error@-1 {{no matching function for call}}
+    }
+  } // namespace expr
+  namespace packs {
+    template <class T1, class ...T2s> struct A {
+      static constexpr auto val = sizeof...(T2s);
+    };
+
+    template <template <class T3> class TT> void f(TT<int> v) {
+      // old-note@-1 {{template template argument has different template parameters}}
+      // new-note@-2 {{deduced type 'A<[...], (no argument), (no argument), (no argument)>' of 1st parameter does not match adjusted type 'A<[...], void, void, void>' of argument [with TT = A]}}
+      static_assert(v.val == 3);
+    };
+    void test() {
+      f(A<int, void, void, void>());
+      // expected-error@-1 {{no matching function for call}}
+    }
+  } // namespace packs
+} // namespace classes
+
 namespace regression1 {
   template <typename T, typename Y> struct map {};
   template <typename T> class foo {};

libcxx/include/__chrono/time_zone.h

@@ -16,7 +16,9 @@
 // Enable the contents of the header only when libc++ was built with experimental features enabled.
 #if !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_TZDB)
 
+#  include <__chrono/calendar.h>
 #  include <__chrono/duration.h>
+#  include <__chrono/local_info.h>
 #  include <__chrono/sys_info.h>
 #  include <__chrono/system_clock.h>
 #  include <__compare/strong_order.h>
@@ -63,12 +65,18 @@ class _LIBCPP_AVAILABILITY_TZDB time_zone {
     return __get_info(chrono::time_point_cast<seconds>(__time));
   }
 
+  template <class _Duration>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI local_info get_info(const local_time<_Duration>& __time) const {
+    return __get_info(chrono::time_point_cast<seconds>(__time));
+  }
+
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const __impl& __implementation() const noexcept { return *__impl_; }
 
 private:
   [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI string_view __name() const noexcept;
 
   [[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI sys_info __get_info(sys_seconds __time) const;
+  [[nodiscard]] _LIBCPP_AVAILABILITY_TZDB _LIBCPP_EXPORTED_FROM_ABI local_info __get_info(local_seconds __time) const;
 
   unique_ptr<__impl> __impl_;
 };

libcxx/include/chrono

@@ -763,6 +763,9 @@ class time_zone {
 
   template<class Duration>
   sys_info get_info(const sys_time<Duration>& st) const;
+
+  template<class Duration>
+  local_info get_info(const local_time<Duration>& tp) const;
 };
 bool operator==(const time_zone& x, const time_zone& y) noexcept;                // C++20
 strong_ordering operator<=>(const time_zone& x, const time_zone& y) noexcept;    // C++20