This macro is unnecessary with `basic_string& operator=(value_type
__c)`.

Some of the checks in sfinae_helpers.h were not used anymore since we
refactored the std::tuple implementation and were now dead code. This
patch removes the code.

The <__threading_support> header is a huge beast and it's really
difficult to navigate. I find myself struggling to find what I want
every time I have to open it, and I've been considering splitting it up
for years for that reason.

This patch aims not to contain any functional change. The various
implementations of the threading base are simply moved to separate
headers and then the individual headers are simplified in mechanical
ways. For example, we used to have redundant declarations of all the
functions at the top of `__threading_support`, and those are removed
since they are not needed anymore. The various #ifdefs are also
simplified and removed when they become unnecessary.

Finally, this patch adds documentation for the API we expect from any
threading implementation.

This prevents having to use double parentheses in common cases.

[Clang][Sema] Allow elaborated-type-specifiers that declare member class template explict specializations (#78720)

According to [[dcl.type.elab]
p2](http://eel.is/c++draft/dcl.type.elab#2):
> If an
[elaborated-type-specifier](http://eel.is/c++draft/dcl.type.elab#nt:elaborated-type-specifier)
is the sole constituent of a declaration, the declaration is ill-formed
unless it is an explicit specialization, an explicit instantiation or it
has one of the following forms [...]

Consider the following:
```cpp
template<typename T>
struct A 
{
    template<typename U>
    struct B;
};

template<>
template<typename U>
struct A<int>::B; // #1
```
The _elaborated-type-specifier_ at `#1` declares an explicit
specialization (which is itself a template). We currently (incorrectly)
reject this, and this PR fixes that.

I moved the point at which _elaborated-type-specifiers_ with
_nested-name-specifiers_ are diagnosed from `ParsedFreeStandingDeclSpec`
to `ActOnTag` for two reasons: `ActOnTag` isn't called for explicit
instantiations and partial/explicit specializations, and because it's
where we determine if a member specialization is being declared.

With respect to diagnostics, I am currently issuing the diagnostic
without marking the declaration as invalid or returning early, which
results in more diagnostics that I think is necessary. I would like
feedback regarding what the "correct" behavior should be here.

Another round of additional tests for
https://github.com/llvm/llvm-project/pull/7863
with different sext/zext and use variants.

This patch tries to better explain the differences between the
`IsTargetDevice` and `IsGPU` flags of the `OpenMPIRBuilderConfig`.

Those were deprecated and basically not used anymore after we renamed
them in batch. This patch removes the macros entirely.

`OpaqueValueExpr` doesn't necessarily contain a source expression.
Particularly, after #78041, it is used to carry the type and the value
kind of a non-type template argument of floating-point type or referring
to a subobject (those are so called `StructuralValue` arguments).

This fixes #79575.

Minor correction for #79775 - noticed in EXPENSIVE_CHECKS builds

Stop clang-format trying to expand manually compressed lookup switch() code - if it still fits into 80col, then keep it to a single line instead of expanding across multiple lines each.

This is a follow-up for the comparison of constraints on out-of-line
function template definitions. We require the instantiation of a
ParmVarDecl while transforming the expression if that Decl gets
referenced by a DeclRefExpr. However, we're not actually performing the
class or function template instantiation at the time of such comparison.
Therefore, let's map these parameters to themselves so that they get
preserved after the substitution.

Fixes https://github.com/llvm/llvm-project/issues/74447.

reserveRegisterTuples is slow because it uses MCRegAliasIterator and
hence ends up reserving the same aliased registers many times. This
patch changes getReservedRegs not to use it for reserving SGPRs, VGPRs
and AGPRs. Instead it iterates through base register classes, which
should come closer to reserving each register once only.

Overall this speeds up the time to run check-llvm-codegen-amdgpu in my
Release build from 18.4 seconds to 16.9 seconds (all timings +/- 0.2).

There is no `SHL` used in canonicalization in `arith`

---------

Co-authored-by: Jakub Kuderski <kubakuderski@gmail.com>
Co-authored-by: Tobias Gysi <tobias.gysi@nextsilicon.com>

Reverts llvm/llvm-project#78120

Buildbot is broken:

llvm/lib/Support/RISCVISAInfo.cpp:910:18: error: call to deleted
constructor of 'llvm::Error'
          return E;
                 ^

when possible.

Otherwise SCEV asserts `Can't extend pointer!`

Fixes SWDEV-442670

This patch follows the latest ACLE specification as shown in PR
https://github.com/ARM-software/acle/pull/279. It adjusts the
priorities for FEAT_DOTPROD, FEAT_SM4, FEAT_FP16FML, FEAT_RDM.

Add tests for empty pack deduction from function arguments.

And link to it from the GitHub guide. Since it fits in the flow of the
former document better, but is of interest to those using the GitHub
specific guide.

This includes some content I wrote for an automated PR comment but I
think is useful to have in a single place to link to instead.

I have removed some details:
* About the waterfall view because it doesn't seem that useful to new
contributors and is likely to just seem like constant chaos given how
many builds are going on.
* The orange bubbles in the console view. I also remember this being the
case but whether it was changed, or the web UI is just not loading
properly, I now see red builds that were red before that commit. So
again, it seems like detail that's not needed for a new contributor.

llvm-project/llvm/lib/Target/X86/X86CompressEVEX.cpp:233:15:
error: '&&' within '||' [-Werror,-Wlogical-op-parentheses]
    if (!IsND && !IsMovberr || !isRedundantNewDataDest(MI, ST))
        ~~~~~~^~~~~~~~~~~~~ ~~
llvm-project/llvm/lib/Target/X86/X86CompressEVEX.cpp:233:15:
note: place parentheses around the '&&' expression to silence this warning
    if (!IsND && !IsMovberr || !isRedundantNewDataDest(MI, ST))
              ^
        (                  )
1 error generated.

This test is platform agnostic, it runs all tests on all architectures.

Specifying an enum case of an enum attr currently requires the use of
either `NativeCodeCall` or a `ConstantAttr` specifying the full C++ name
of the enum case. The disadvantages of both are less readable code due
to including C++ expressions and very few checks of any kind, creating
C++ code that does not compile instead.

This PR adds `ConstantEnumCase`, a kind of `ConstantAttr` which
automatically derives the correct value representation from a given enum
and the string representation of an enum case. It supports both
`EnumAttrInfo`s (enums wrapping `IntegerAttr`) and `EnumAttr` (proper
dialect attributes). It even supports bit-enums, allowing one to list
multiple enum cases and have them be combined. If an enum case is not
found, an assertion is triggered with a proper error message.

Besides the tests, it was also used to simplify DRR patterns in the
arith dialect.

The class member is already const.

APX promoted MOVBE instructions were supported in #77431. The reg2reg
variants of MOVBE are newly introduced by APX and can be optimized to
BSWAP instruction when the 2 register operands are same.

This patch adds manual entries for MOVBErr instructions when we do ndd
to non-ndd compression #77731.
RFC:
https://discourse.llvm.org/t/rfc-design-for-apx-feature-egpr-and-ndd-support/73031/4

This patch is split off from #77342, and follows #79103

- Correct for CodeSize cost that 1 instruction is not included. 3 is
from {VMV.S, ReductionOp, VMV.X}
- Add SplitCost which chains a series of VMAX/VMIN/... which scales with
LMUL.
- Use MVT to estimate VL.

This supports dead-strip for objc stubs.

Assertion failure `(i >= FTy->getNumParams() || FTy->getParamType(i) ==
Args[i]->getType()) && "Calling a function with a bad signature!"'. The
'llvm.memcpy' intercepted by ASan instrumentation pass is implemented by
it's own __asan_memcpy implementation. The second argument of
llvm.memcpy accepts ptr to addrspace(4), __asan_memcpy also has to
follow ptr to addrspace(4) convention.

---------

Co-authored-by: Amit Pandey <amit.pandey@amd.com>

Follow
https://github.com/riscv-non-isa/riscv-toolchain-conventions/pull/14 by
dropping the order requirement of `-march`.

1. single-letter extension can be arbitrary order
    - march=rv32iamdf 
2. single-letter extension and multi-letter extension can be mixed
    - march=rv32i_zihintntl_m_a_f_d_svinval
3. multi-letter extension need seperate the following extension by
underscore, otherwise it will be intreprete as one extension.
    - march=rv32i_zbam -> i,zbam
    - march=rv32i_zba_m -> i,zba,m

[X86][MC] Support  encoding optimization & assembler relaxation about immediate operands for APX instructions (#78545)

Encoding optimization:
```
mi/mi32 -> mi8
ri/ri32 -> ri8
```
if the immediate operand is 8-bit wide.

Assembler relaxation:
```
mi8 -> mi/mi32
ri8 -> ri/ri32
```
If the immediate operand is a symbol expression and it's value is
unknown.

[RISCV] Don't use pointer operand in MemoryLocation for RISC-V strided and indexed load/store intrinsics. (#79890)

It seems that even though we set the size to unknown, there is still an
assumption in alias analysis somewhere that we will only access bytes
*after* the pointer. Since a strided/indexed load/store can have
negative indices, this is not accurate.

This was found in our downstream when the scheduler reordered a strided
load with negative stride above a scalar store that aliased with it.

Exclude some using-declarations in the module purview when compiling
with `-fno-char8_t`.

The canonicalization incrementally converts foldable dynamic hi/lo
padding to static hi/lo values. During this canonicalization the
static-fied valued should be removed from the dynamic values.

Followup to #79884.

The linker adds __start_foo/__stop_foo symbols pointing to the
beginning/end of the foo section. These can be far away from text, so
treat them as large symbols under the medium/large code models.
Performance to access these is almost certainly not important.

Clean up the code before making more substantial changes. NFC modulo
extra error checking and physical storage buffer storage class handling.

* Add switch case for physical storage buffer
* Handle type conversion failures
* Inline methods to reduce scrolling
* Other minor cleanups