Merge commit '73ac3b137101594663aad9901598dfa1aced9c78' into feature/merge-upstream-20220203

Author: kaz7

bolt/lib/Target/X86/X86MCPlusBuilder.cpp

@@ -1873,13 +1873,9 @@ class X86MCPlusBuilder : public MCPlusBuilder {
       NewOpcode = Check.second;
       if (Check.first == NOCHECK)
         break;
-      if (Check.first == CHECK8 &&
-          ImmVal >= std::numeric_limits<int8_t>::min() &&
-          ImmVal <= std::numeric_limits<int8_t>::max())
+      if (Check.first == CHECK8 && isInt<8>(ImmVal))
         break;
-      if (Check.first == CHECK32 &&
-          ImmVal >= std::numeric_limits<int32_t>::min() &&
-          ImmVal <= std::numeric_limits<int32_t>::max())
+      if (Check.first == CHECK32 && isInt<32>(ImmVal))
         break;
     }
     if (NewOpcode == Inst.getOpcode())
@@ -3012,12 +3008,9 @@ class X86MCPlusBuilder : public MCPlusBuilder {
       NewOpcode = Check.second;
       if (Check.first == NOCHECK)
         break;
-      if (Check.first == CHECK8 && Imm >= std::numeric_limits<int8_t>::min() &&
-          Imm <= std::numeric_limits<int8_t>::max())
+      if (Check.first == CHECK8 && isInt<8>(Imm))
         break;
-      if (Check.first == CHECK32 &&
-          Imm >= std::numeric_limits<int32_t>::min() &&
-          Imm <= std::numeric_limits<int32_t>::max())
+      if (Check.first == CHECK32 && isInt<32>(Imm))
         break;
     }
     if (NewOpcode == Inst.getOpcode())

bolt/test/CMakeLists.txt

@@ -38,6 +38,7 @@ list(APPEND BOLT_TEST_DEPS
   llvm-config
   llvm-bolt
   llvm-boltdiff
+  llvm-bolt-heatmap
   llvm-dwarfdump
   llvm-mc
   llvm-nm

bolt/test/heatmap.test

@@ -0,0 +1,12 @@
+# Verifies basic functioning of heatmap mode
+
+REQUIRES: system-linux
+XFAIL: *
+
+RUN: llvm-bolt heatmap --help | FileCheck %s --check-prefix=CHECK-SUBCOMMAND
+CHECK-SUBCOMMAND: SUBCOMMAND 'heatmap': generate heatmap
+CHECK-SUBCOMMAND: USAGE: llvm-bolt heatmap [options] <executable>
+
+RUN: llvm-bolt-heatmap --help | FileCheck %s --check-prefix=CHECK-STANDALONE
+CHECK-STANDALONE: SUBCOMMAND 'heatmap': generate heatmap
+CHECK-STANDALONE: USAGE: llvm-bolt-heatmap heatmap [options] <executable>

bolt/test/lit.cfg.py

@@ -73,6 +73,7 @@
     ToolSubst('llvm-dwarfdump', unresolved='fatal'),
     ToolSubst('llvm-bolt', unresolved='fatal'),
     ToolSubst('llvm-boltdiff', unresolved='fatal'),
+    ToolSubst('llvm-bolt-heatmap', unresolved='fatal'),
     ToolSubst('perf2bolt', unresolved='fatal'),
     ToolSubst('yaml2obj', unresolved='fatal'),
     ToolSubst('llvm-mc', unresolved='fatal'),

clang/docs/CommandGuide/clang.rst

@@ -323,7 +323,11 @@ number of cross compilers, or may only support a native target.
 
 .. option:: -arch <architecture>
 
-  Specify the architecture to build for.
+  Specify the architecture to build for (Mac OS X specific).
+
+.. option:: -target <architecture>
+
+  Specify the architecture to build for (all platforms).
 
 .. option:: -mmacosx-version-min=<version>
 

clang/docs/LanguageExtensions.rst

@@ -1430,6 +1430,11 @@ The following type trait primitives are supported by Clang. Those traits marked
 * ``__is_trivially_constructible`` (C++, GNU, Microsoft)
 * ``__is_trivially_copyable`` (C++, GNU, Microsoft)
 * ``__is_trivially_destructible`` (C++, MSVC 2013)
+* ``__is_trivially_relocatable`` (Clang): Returns true if moving an object
+  of the given type, and then destroying the source object, is known to be
+  functionally equivalent to copying the underlying bytes and then dropping the
+  source object on the floor. This is true of trivial types and types which
+  were made trivially relocatable via the ``clang::trivial_abi`` attribute.
 * ``__is_union`` (C++, GNU, Microsoft, Embarcadero)
 * ``__is_unsigned`` (C++, Embarcadero):
   Returns false for enumeration types. Note, before Clang 13, returned true for

clang/docs/ReleaseNotes.rst

@@ -67,6 +67,9 @@ Modified Compiler Flags
 Removed Compiler Flags
 -------------------------
 
+- -Wweak-template-vtables, which was deprecated in the previous release and no
+  longer had any effect, has been removed.
+
 New Pragmas in Clang
 --------------------
 

clang/include/clang/AST/Type.h

@@ -829,6 +829,8 @@ class QualType {
   /// Return true if this is a trivially copyable type (C++0x [basic.types]p9)
   bool isTriviallyCopyableType(const ASTContext &Context) const;
 
+  /// Return true if this is a trivially relocatable type.
+  bool isTriviallyRelocatableType(const ASTContext &Context) const;
 
   /// Returns true if it is a class and it might be dynamic.
   bool mayBeDynamicClass() const;

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

@@ -600,17 +600,15 @@ class Matcher {
   /// Convert \c this into a \c Matcher<T> by applying dyn_cast<> to the
   /// argument.
   /// \c To must be a base class of \c T.
-  template <typename To> Matcher<To> dynCastTo() const LLVM_LVALUE_FUNCTION {
+  template <typename To> Matcher<To> dynCastTo() const & {
     static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
     return Matcher<To>(Implementation);
   }
 
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
   template <typename To> Matcher<To> dynCastTo() && {
     static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
     return Matcher<To>(std::move(Implementation));
   }
-#endif
 
   /// Forwards the call to the underlying MatcherInterface<T> pointer.
   bool matches(const T &Node,
@@ -628,13 +626,9 @@ class Matcher {
   ///
   /// The returned matcher keeps the same restrictions as \c this and remembers
   /// that it is meant to support nodes of type \c T.
-  operator DynTypedMatcher() const LLVM_LVALUE_FUNCTION {
-    return Implementation;
-  }
+  operator DynTypedMatcher() const & { return Implementation; }
 
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
   operator DynTypedMatcher() && { return std::move(Implementation); }
-#endif
 
   /// Allows the conversion of a \c Matcher<Type> to a \c
   /// Matcher<QualType>.
@@ -1361,35 +1355,31 @@ template <typename... Ps> class VariadicOperatorMatcher {
   VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op, Ps &&... Params)
       : Op(Op), Params(std::forward<Ps>(Params)...) {}
 
-  template <typename T> operator Matcher<T>() const LLVM_LVALUE_FUNCTION {
+  template <typename T> operator Matcher<T>() const & {
     return DynTypedMatcher::constructVariadic(
                Op, ASTNodeKind::getFromNodeKind<T>(),
                getMatchers<T>(std::index_sequence_for<Ps...>()))
         .template unconditionalConvertTo<T>();
   }
 
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
   template <typename T> operator Matcher<T>() && {
     return DynTypedMatcher::constructVariadic(
                Op, ASTNodeKind::getFromNodeKind<T>(),
                getMatchers<T>(std::index_sequence_for<Ps...>()))
         .template unconditionalConvertTo<T>();
   }
-#endif
+
 private:
   // Helper method to unpack the tuple into a vector.
   template <typename T, std::size_t... Is>
-  std::vector<DynTypedMatcher>
-  getMatchers(std::index_sequence<Is...>) const LLVM_LVALUE_FUNCTION {
+  std::vector<DynTypedMatcher> getMatchers(std::index_sequence<Is...>) const & {
     return {Matcher<T>(std::get<Is>(Params))...};
   }
 
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
   template <typename T, std::size_t... Is>
   std::vector<DynTypedMatcher> getMatchers(std::index_sequence<Is...>) && {
     return {Matcher<T>(std::get<Is>(std::move(Params)))...};
   }
-#endif
 
   const DynTypedMatcher::VariadicOperator Op;
   std::tuple<Ps...> Params;
@@ -1479,15 +1469,13 @@ class ArgumentAdaptingMatcherFuncAdaptor {
 
   using ReturnTypes = ToTypes;
 
-  template <typename To> operator Matcher<To>() const LLVM_LVALUE_FUNCTION {
+  template <typename To> operator Matcher<To>() const & {
     return Matcher<To>(new ArgumentAdapterT<To, T>(InnerMatcher));
   }
 
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
   template <typename To> operator Matcher<To>() && {
     return Matcher<To>(new ArgumentAdapterT<To, T>(std::move(InnerMatcher)));
   }
-#endif
 
 private:
   Matcher<T> InnerMatcher;
@@ -1558,21 +1546,19 @@ template <typename MatcherType> class TraversalWrapper {
   TraversalWrapper(TraversalKind TK, const MatcherType &InnerMatcher)
       : TK(TK), InnerMatcher(InnerMatcher) {}
 
-  template <typename T> operator Matcher<T>() const LLVM_LVALUE_FUNCTION {
+  template <typename T> operator Matcher<T>() const & {
     return internal::DynTypedMatcher::constructRestrictedWrapper(
                new internal::TraversalMatcher<T>(TK, InnerMatcher),
                ASTNodeKind::getFromNodeKind<T>())
         .template unconditionalConvertTo<T>();
   }
 
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
   template <typename T> operator Matcher<T>() && {
     return internal::DynTypedMatcher::constructRestrictedWrapper(
                new internal::TraversalMatcher<T>(TK, std::move(InnerMatcher)),
                ASTNodeKind::getFromNodeKind<T>())
         .template unconditionalConvertTo<T>();
   }
-#endif
 
 private:
   TraversalKind TK;
@@ -1599,20 +1585,18 @@ class PolymorphicMatcher {
 
   using ReturnTypes = typename ExtractFunctionArgMeta<ReturnTypesF>::type;
 
-  template <typename T> operator Matcher<T>() const LLVM_LVALUE_FUNCTION {
+  template <typename T> operator Matcher<T>() const & {
     static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
                   "right polymorphic conversion");
     return Matcher<T>(new_from_tuple<MatcherT<T, ParamTypes...>>(Params));
   }
 
-#if LLVM_HAS_RVALUE_REFERENCE_THIS
   template <typename T> operator Matcher<T>() && {
     static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
                   "right polymorphic conversion");
     return Matcher<T>(
         new_from_tuple<MatcherT<T, ParamTypes...>>(std::move(Params)));
   }
-#endif
 
 private:
   std::tuple<ParamTypes...> Params;

clang/include/clang/Basic/AttrDocs.td

@@ -3295,6 +3295,9 @@ If a type is trivial for the purposes of calls, has a non-trivial destructor,
 and is passed as an argument by value, the convention is that the callee will
 destroy the object before returning.
 
+If a type is trivial for the purpose of calls, it is assumed to be trivially
+relocatable for the purpose of ``__is_trivially_relocatable``.
+
 Attribute ``trivial_abi`` has no effect in the following cases:
 
 - The class directly declares a virtual base or virtual methods.