Merge branch 'main' into qualwg-docs-restructure

Author: IamYJLee

llvm/docs/FAQ.rst

@@ -50,7 +50,7 @@ test LLVM have been ported to a plethora of platforms.
 What API do I use to store a value to one of the virtual registers in LLVM IR's SSA representation?
 ---------------------------------------------------------------------------------------------------
 
-In short: you can't. It's actually kind of a silly question once you grok
+In short: you can't. It's actually kind of a silly question once you understand
 what's going on. Basically, in code like:
 
 .. code-block:: llvm
@@ -80,7 +80,7 @@ What source languages are supported?
 
 LLVM currently has full support for C and C++ source languages through
 `Clang <https://clang.llvm.org/>`_. Many other language frontends have
-been written using LLVM, and an incomplete list is available at
+been written using LLVM; an incomplete list is available at
 `projects with LLVM <https://llvm.org/ProjectsWithLLVM/>`_.
 
 
@@ -91,12 +91,12 @@ LLVM intermediate representation (IR) format. Assuming you want to write your
 language's compiler in the language itself (rather than C++), there are 3
 major ways to tackle generating LLVM IR from a front-end:
 
-1. **Call into the LLVM libraries code using your language's FFI (foreign
+1. **Call into the LLVM libraries using your language's FFI (foreign
    function interface).**
 
   * *for:* best tracks changes to the LLVM IR, .ll syntax, and .bc format
 
-  * *for:* enables running LLVM optimization passes without a emit/parse
+  * *for:* enables running LLVM optimization passes without an emit/parse
     overhead
 
   * *for:* adapts well to a JIT context
@@ -128,10 +128,10 @@ most common hurdle with calling C from managed code is interfacing with the
 garbage collector. The C interface was designed to require very little memory
 management, and so is straightforward in this regard.
 
-What support is there for a higher level source language constructs for building a compiler?
+What support is there for a higher-level source language constructs for building a compiler?
 --------------------------------------------------------------------------------------------
 Currently, there isn't much. LLVM supports an intermediate representation
-which is useful for code representation but will not support the high level
+which is useful for code representation but will not support the high-level
 (abstract syntax tree) representation needed by most compilers. There are no
 facilities for lexical nor semantic analysis.
 
@@ -215,7 +215,7 @@ for it.
 
 Why does instcombine + simplifycfg turn a call to a function with a mismatched calling convention into "unreachable"? Why not make the verifier reject it?
 ----------------------------------------------------------------------------------------------------------------------------------------------------------
-This is a common problem run into by authors of front-ends that are using
+This is a common problem encountered by authors of front-ends that are using
 custom calling conventions: you need to make sure to set the right calling
 convention on both the function and on each call to the function.  For
 example, this code:
@@ -274,7 +274,7 @@ Here's an example:
    }
 
 In this example, "test" always passes ``@foo``/``false`` into ``bar``, which
-ensures that it is dynamically called with the right calling conv (thus, the
+ensures that it is dynamically called with the right calling convention (thus, the
 code is perfectly well defined).  If you run this through the inliner, you
 get this (the explicit "or" is there so that the inliner doesn't dead code
 eliminate a bunch of stuff):

llvm/include/llvm/ADT/FunctionExtras.h

@@ -231,22 +231,22 @@ template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
 
   // The pointers to call/move/destroy functions are determined for each
   // callable type (and called-as type, which determines the overload chosen).
-  // (definitions are out-of-line).
 
   // By default, we need an object that contains all the different
   // type erased behaviors needed. Create a static instance of the struct type
   // here and each instance will contain a pointer to it.
   // Wrap in a struct to avoid https://gcc.gnu.org/PR71954
   template <typename CallableT, typename CalledAs, typename Enable = void>
   struct CallbacksHolder {
-    static NonTrivialCallbacks Callbacks;
+    inline static NonTrivialCallbacks Callbacks = {
+        &CallImpl<CalledAs>, &MoveImpl<CallableT>, &DestroyImpl<CallableT>};
   };
   // See if we can create a trivial callback. We need the callable to be
   // trivially moved and trivially destroyed so that we don't have to store
   // type erased callbacks for those operations.
   template <typename CallableT, typename CalledAs>
   struct CallbacksHolder<CallableT, CalledAs, EnableIfTrivial<CallableT>> {
-    static TrivialCallback Callbacks;
+    inline static TrivialCallback Callbacks = {&CallImpl<CalledAs>};
   };
 
   // A simple tag type so the call-as type to be passed to the constructor.
@@ -344,19 +344,6 @@ template <typename ReturnT, typename... ParamTs> class UniqueFunctionBase {
   }
 };
 
-template <typename R, typename... P>
-template <typename CallableT, typename CalledAsT, typename Enable>
-typename UniqueFunctionBase<R, P...>::NonTrivialCallbacks UniqueFunctionBase<
-    R, P...>::CallbacksHolder<CallableT, CalledAsT, Enable>::Callbacks = {
-    &CallImpl<CalledAsT>, &MoveImpl<CallableT>, &DestroyImpl<CallableT>};
-
-template <typename R, typename... P>
-template <typename CallableT, typename CalledAsT>
-typename UniqueFunctionBase<R, P...>::TrivialCallback
-    UniqueFunctionBase<R, P...>::CallbacksHolder<
-        CallableT, CalledAsT, EnableIfTrivial<CallableT>>::Callbacks{
-        &CallImpl<CalledAsT>};
-
 } // namespace detail
 
 template <typename R, typename... P>

llvm/include/llvm/ADT/SmallVector.h

@@ -212,17 +212,16 @@ class SmallVectorTemplateCommon
   void assertSafeToReferenceAfterClear(ItTy, ItTy) {}
 
   /// Check whether any part of the range will be invalidated by growing.
-  void assertSafeToAddRange(const T *From, const T *To) {
-    if (From == To)
-      return;
-    this->assertSafeToAdd(From, To - From);
-    this->assertSafeToAdd(To - 1, To - From);
+  template <class ItTy> void assertSafeToAddRange(ItTy From, ItTy To) {
+    if constexpr (std::is_pointer_v<ItTy> &&
+                  std::is_same_v<std::remove_cv_t<std::remove_pointer_t<ItTy>>,
+                                 T>) {
+      if (From == To)
+        return;
+      this->assertSafeToAdd(From, To - From);
+      this->assertSafeToAdd(To - 1, To - From);
+    }
   }
-  template <
-      class ItTy,
-      std::enable_if_t<!std::is_same<std::remove_const_t<ItTy>, T *>::value,
-                       bool> = false>
-  void assertSafeToAddRange(ItTy, ItTy) {}
 
   /// Reserve enough space to add one element, and return the updated element
   /// pointer in case it was a reference to the storage.

llvm/lib/ExecutionEngine/JITLink/MachOLinkGraphBuilder.cpp

@@ -203,9 +203,8 @@ Error MachOLinkGraphBuilder::createNormalizedSections() {
   llvm::sort(Sections,
              [](const NormalizedSection *LHS, const NormalizedSection *RHS) {
                assert(LHS && RHS && "Null section?");
-               if (LHS->Address != RHS->Address)
-                 return LHS->Address < RHS->Address;
-               return LHS->Size < RHS->Size;
+               return std::tie(LHS->Address, LHS->Size) <
+                      std::tie(RHS->Address, RHS->Size);
              });
 
   for (unsigned I = 0, E = Sections.size() - 1; I != E; ++I) {

llvm/lib/Target/AMDGPU/Utils/AMDKernelCodeTUtils.cpp

@@ -56,18 +56,15 @@ using namespace llvm::AMDGPU;
                        std::true_type>;                                        \
   };                                                                           \
   class IsMCExpr##member {                                                     \
-    template <typename U,                                                      \
-              typename std::enable_if_t<                                       \
-                  HasMember##member::RESULT &&                                 \
-                      std::is_same_v<decltype(U::member), const MCExpr *>,     \
-                  U> * = nullptr>                                              \
-    static constexpr std::true_type HasMCExprType(decltype(U::member) *);      \
+    template <typename U>                                                      \
+    static constexpr auto HasMCExprType(int) -> std::bool_constant<            \
+        HasMember##member::RESULT &&                                           \
+        std::is_same_v<decltype(U::member), const MCExpr *>>;                  \
     template <typename U> static constexpr std::false_type HasMCExprType(...); \
                                                                                \
   public:                                                                      \
     static constexpr bool RESULT =                                             \
-        std::is_same_v<decltype(HasMCExprType<AMDGPUMCKernelCodeT>(nullptr)),  \
-                       std::true_type>;                                        \
+        decltype(HasMCExprType<AMDGPUMCKernelCodeT>(0))::value;                \
   };                                                                           \
   class GetMember##member {                                                    \
   public:                                                                      \