[flang] Detect obvious argument shape incompatibility when checking procedure compatibility

The compiler presently detects different dummy object array ranks;
extend the compatibility check to also note discrepancies in corresponding
constant dummy argument extents.

Differential Revision: https://reviews.llvm.org/D145748

[flang] Diagnose ridiculously large kind parameters

Kind parameters on literals (1_4, 1.0_8, 4_"Unicode") are not
being caught as errors if they're extremely large integer values
that become valid when truncated to C++'s int type.

Differential Revision: https://reviews.llvm.org/D145747

[flang] Check dummy arguments of BIND(C) procedures

Declaration checking in semantics was only examining symbols with
explicit BIND(C) attributes; extend it to also check dummy arguments
to such procedures.

Differential Revision: https://reviews.llvm.org/D145746

[flang][runtime] Catch infinite unlimited format repetition better

The runtime check for infinite unlimited format repetition is missing
the case of implicit unlimited format repetition at the top level
without finding the next data edit descriptor that corresponds with
a data list item.

Replace the check with a Boolean flag that detects unlimited
repetition hitting a right parenthesis and restarting, and fail
when it happens the second time.

Differential Revision: https://reviews.llvm.org/D145745

[ConstraintElim] Update test to use variable start value.

Otherwise %x <= 10 will be true on the first iteration, making the latch
dead. This makes the test more robust to CE becoming more powerful in
the future.

[flang] Forward references to COMMON from specification expr under IMPLICIT NONE

As a near-universal extension, Fortran compilers permit forward references
to dummy arguments and variables in COMMON blocks from specification expressions
before an explicit type-declaration-stmt appears for those variables
under IMPLICIT NONE, so long as those variables are later explicitly typed
with the types that regular implicit typing rules would have given them
(usually default INTEGER).

F18 implemented this extension for dummy arguments, but not variables in
COMMON blocks.  Extend the extension to also accept variables in COMMON.

Differential Revision: https://reviews.llvm.org/D145743

[RISCV] Support Zfa fli instructions with vector splats.

-Return false from RISCVDAGToDAGISel::selectFPImm for fli
 constants so we don't try to use integer expansion.
-Support fli.h with Zvfh+Zfhmin.

Reviewed By: reames

Differential Revision: https://reviews.llvm.org/D145766

[mlir] Add mlir::LLVM::FastmathFlags to LLVM instrinsic vector reductions

Rationale:
The LLVM dialect supports passing fastmath flags from floating point ops to LLVMIR instructions. However, not all LLVM ops have the required attribute. This change adds support for fastmath flags to `llvm.intr.vector.reduce.{fmin,fmax}`. One scenario where this is useful is in lowering llvm.intr.vector.reduce.{fmax,fmin} to LLVMIR with `nnan` (NoNans) flag so it may be [[ https://github.com/llvm/llvm-project/blob/115c7beda74f3cfaf83b91d14bc97a39bff4cf19/llvm/lib/CodeGen/ExpandReductions.cpp#L159 | lowered to a shuffle reduction ]].

Changes:

  - Make `LLVM_VecReductionF` implement the `FastmathFlagsInterface`; change is modeled on `LLVM_UnaryIntrOpF`
  - Add an assembly format for `LLVM_VecReductionF` ops. The purpose is to keep existing functionality: avoid printing the fastmath flags attribute when it has its default value (`none`). Change is modeled on `LLVM_UnaryIntrOpBase`

Reviewed By: gysit

Differential Revision: https://reviews.llvm.org/D145692

[flang] Check that a SELECT TYPE selector is not a procedure

A SELECT TYPE statement's selector must be a variable or expression,
not a procedure; specifically, a function with a polymorphic result
is unacceptable.

Differential Revision: https://reviews.llvm.org/D145742

[NFC] [CMake] Cleanup clang tool dependencies

None of these tools need to depend on clang to build, instead the test
target should depend on them.

This prevents rebuilding/linking these tools when building the `clang`
target directly.

[flang] Ignore FINAL subroutines with mismatching type parameters

When a parameterized derived type has FINAL subroutines, only
those FINAL subroutines whose dummy argument's type matches the
type parameter values of a particular instantiation are relevant
to that instantiation.

Differential Revision: https://reviews.llvm.org/D145741

Reland D144768 "[scudo] Mitigate page releasing thrashing"

This reverts commit e64fabf51e882cc8e6157b7d139005162adb947c.

Reviewed By: cferris

Differential Revision: https://reviews.llvm.org/D145543

[VPlan] Add VPWidenSelectRecipe::getCond() (NFC).

Add helper to access condition, as suggested in D144489.

[flang] Fix crash in folding TRANSFER() with MOLD=substring

When a substring appears as the MOLD= argument to TRANSFER(),
it's possible for the compiler to assert if it can't figure
out a constant length for the substring.  Fix.

Differential Revision: https://reviews.llvm.org/D145740

[RISCV] Enable Zfa fli.h instruction in MC layer with Zfhmin and Zvfh.

According to the spec this instruction is can be enabled with Zfh
and Zvfh (which requires Zfhmin). The other instructions f16
instructions from Zfa require Zfh.

Reviewed By: reames

Differential Revision: https://reviews.llvm.org/D145649

[SLP][NFC]Update/simplify test to avoid dead code elimination.

[RISCV] Print Zfa fli instruction FP values in a more adaptive way.

Previously, we printed all constants in scientific notation with
6 digits of precision. This is not enough to accurately display
the smallest value, but increasing the precision would be too much
for other values.

This patch prints values with fractional bits using only as many digits as
needed. 1*2^-15 and 1*2^-16 will be printed in scientific notation while
the others are printed without scientific notation. The integer values
are printed with a single 0 after the decimal point.

Reviewed By: reames

Differential Revision: https://reviews.llvm.org/D145645

[TargetParser] Disallow Global Constructors

Global Constructors are disallowed in the Support library. The
TargetParser library is likely to go along with the Support library in
most uses, because it contains llvm::Triple, so lets pre-emptively add
the same rule, rather than getting caught out later.

Differential Revision: https://reviews.llvm.org/D145249

[DebugInfo][DWARF][NFC] follow LLVM style guideline about namespaces.

[LICM] Delay fetching of preheader (NFC)

Only fetch preheader once we want to actually hoist. It turns out
that calculating the preheader is expensive enough to affect
overall compile-time if you do it for every single instruction.

Addresses the compile-time regression from D143726.

[AArch64] NFC: Merge addTypeForStreamingSVE and addTypeForFixedLengthSVE

The two functions are basically identical, with a few minor exceptions.
They've been merged into a single function that distinguishes based on
a 'bool StreamingSVE' argument.

[GlobalOpt] Add test where the initializer evaluation fails.

Test coverage for D145490.

[gn build] Port 54178fc6161a

[AMDGPU] Make use of defvar in defining SMEM Real instructions

[VPlan] Replace InvariantCond field from VPWidenSelectRecipe.

There is no need to store information about invariance in the recipe.
Replace the fields with checks of the operands using
isDefinedOutsideVectorRegions.

Reviewed By: Ayal

Differential Revision: https://reviews.llvm.org/D144489

[AArch64] Remove fixed FIXMEs from D120706. NFC

These comments were not adjusted when the fix went in.

Reserve unused bits in struct CXIndexOptions; NFC

Differential Revision: https://reviews.llvm.org/D145783

Improve documentation of CXIndexOptions; NFC

Document one more alternative way to initialize struct CXIndexOptions,
which is used in LibclangSetPreambleStoragePathTest since
df8f8f76207df40dca11c9c0c2328d6b3dfba9ca because the previous
initialization approach causes compiler warnings.

Differential Revision: https://reviews.llvm.org/D145775

[Clang] Convert some tests to opaque pointers (NFC)

[libc++] Clean up old macOS back-deployment workarounds

This patch bumps the minimum macOS version for building the dylib
or back-deploying a statically-linked libc++ from macOS 10.11 to
macOS 10.13. AFAICT, Chrome was the last one to require macOS 10.11,
but since then they have bumped their minimal supported version to
macOS 10.13.

Differential Revision: https://reviews.llvm.org/D145012

[clang-tidy] Finish cppcoreguidelines-avoid-capturing-lambda-coroutines check

This commit implements check for CP.51 C++ Core Guidelines

Depends on D137514

Reviewed By: ChuanqiXu

Differential Revision: https://reviews.llvm.org/D145720

[clang-tidy] add check for capturing lambda coroutines

Signed-off-by: Noah Watkins <noah@redpanda.com>
Reviewed By: ChuanqiXu

Differential Revision: https://reviews.llvm.org/D137514

[libc++] Remove _LIBCPP_CONSTEVAL

It was only used in one place, and it seems entirely valid to use
constexpr unconditionally in that location.

Note that a different change was attempted, i.e. using consteval
unconditionally. However, this led to http://llvm.org/PR60709.

Differential Revision: https://reviews.llvm.org/D145700

[clang-tidy] Change readability-magic-numbers to allow numbers in type aliases.

This commit introduces an option to the readability-magic-values checker.
The option defaults to false so that the behavior of the checker doesn't change unless specifically enabled.
These commits are supposed to fix https://github.com/llvm/llvm-project/issues/61259

Reviewed By: PiotrZSL

Differential Revision: https://reviews.llvm.org/D145778

[clang-tidy] Fix readability-redundant-string-cstr for smart pointer #576705

Fix the readability-redundant-string-cstr check to correctly replace
calls to c_str() via an overloaded operator-> (such as from an
iterator.)

Previously, the fix for `i->c_str()` would be `*i->`. Using consume_back
to remove any trailing `->` results in the correct `*i`.

Add some lit check test cases too.

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

Reviewed By: PiotrZSL

Differential Revision: https://reviews.llvm.org/D145730

[AMDGPU][MachineVerifier] Fix vdata reg count for MIMG d16

Differential Revision: https://reviews.llvm.org/D145785

[Clang] Convert some tests to opaque pointers (NFC)

Revert "[SLP]Initial support for reshuffling of non-starting buildvector/gather nodes."

This caused verifier errors:

  Instruction does not dominate all uses!
    %8 = insertelement <2 x i64> %7, i64 %pgocount1330, i64 1
    %15 = shufflevector <2 x i64> %8, <2 x i64> poison, <2 x i32> <i32 1, i32 1>
  in function ?NearestInclusiveAncestorAssignedToSlot@SlotScopedTraversal@blink@@SAPAVElement@2@ABV32@@Z

(or register allocator crash when the verifier was disabled).

See comment on the code review.

> Previously only the very first gather/buildvector node might be probed for reshuffling of other nodes.
> But the compiler may do the same for other gather/buildvector nodes too, just need to check the
> dependency and postpone the emission of the dependent nodes, if the origin nodes were not emitted yet.
>
> Part of D110978
>
> Differential Revision: https://reviews.llvm.org/D144958

This reverts commit a611b3f3059e4c3b9e7b914091c3edaef099fd5d.
It also reverts 7a4061ae372b3262703ffeea3b64db89187db611 which depended on the above.

Revert "[Modules] Remove unnecessary check when generating name lookup table in ASTWriter"

This reverts commit db987b9589be1eb604fcb74c85b410469e31485f.

We're seeing failures in modules-enabled builds from within stdlib after
this commit. Errors look like:

In module '...stl_cc_library':
...optional:560:38: error: 'std::__optional_copy_assign_base<unsigned
long>::__optional_copy_assign_base' from module '...optional' is not
present in definition of 'std::__optional_copy_assign_base<unsigned
long>' in module '...optional'
    using __optional_move_base<_Tp>::__optional_move_base;

In module '...stl_cc_library':
...optional:771:11: error: no matching constructor for initialization of '__optional_move_assign_base<unsigned long>'
        : __base(in_place, _VSTD::forward<_Up>(__v)) {}
          ^      ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
llvm-project/clang/include/clang/Basic/CodeGenOptions.h:448:57: note: in instantiation of function template specialization 'std::optional<unsigned long>::optional<int, 0>' requested here
  std::optional<uint64_t> DiagnosticsHotnessThreshold = 0;

I don't have a self-contained reproducer at this point. I'm hoping that
we may be able to share more information about these issues later, if
necessary.

[AArch64] Fix N2 SchedModel for arithmetic and logic ops with cheap LSL

According to the N2 Software Optimization Guide, arithmetic ops with LSL
≤ 4, no flagset logical ops, and flagset logical ops with LSL = 0 have a
latency of 1 and use pipeline group I. However, most of these ops were
being modelled as having a latency of 2 and using pipeline M. The
affected instructions include the "unshifted" versions of ADD/SUB, among
others.

Differential Revision: https://reviews.llvm.org/D145370

[libc++] Granularize <atomic> includes

Reviewed By: ldionne, Mordante, #libc

Spies: arichardson, libcxx-commits

Differential Revision: https://reviews.llvm.org/D144255

[lldb][test] TestInlineNamespaceAlias.py: skip on older compiler versions

This was failing with versions of clang that didn't support the
dsymutil (D143458) and llvm (D143397) changes that are needed for this test.

Remove unused parameters that we tried passing for the `dwarf` variant, which
is an NFC change. LLDB doesn't yet support `-gdwarf-5` debugging yet so
passing it to the `Makefile` would actually cause the test to fail.

[LICM] Support logical AND/OR when hoisting min/max

We can handle logical AND/OR in the same way as arithmetic AND/OR, it only
takes us freezing `RHS2` for which we may introduce a new use which didn't
exist before dynamically.

Differential Revision: https://reviews.llvm.org/D145771
Reviewed By: nikic

[clangd] UnusedIncludes: Strict config now uses the include-cleaner-library implementation.

And remove the classical clangd-own unused-include implementation.

Differential Revision: https://reviews.llvm.org/D145773

[mlir][NFC] reifyResultShapes: Add extra error checking

This change adds a new helper function `mlir::reifyResultShapes` that calls the corresponding interface method and also checks the result produced by the implementation when running in debug mode. Bugs due to incorrect interface implementations can be difficult to debug.

This helper function also reduces the amount of code needed at call sites: the cast to `ReifyRankedShapedTypeOpInterface` is done in the helper function.

Differential Revision: https://reviews.llvm.org/D145777

[mlir][tensor/linalg] Fix bug in reifyResultShapes

`reifyResultShapes` should return an IntegerAttr if and only if the corresponding dimension is static.

Differential Revision: https://reviews.llvm.org/D145702

[LICM] Simplify (X < A && X < B) into (X < MIN(A, B)) if MIN(A, B) is loop-invariant

We don't do this transform in InstCombine in general case for arbitrary values, because cost of
AND and 2 ICMP's isn't higher than of MIN and ICMP. However, LICM also has a notion
about the loop structure. This transform becomes profitable if `A` and `B` are loop-invariant and
`X` is not: by doing this, we can compute min outside the loop.

Differential Revision: https://reviews.llvm.org/D143726
Reviewed By: nikic

Reland "[mlir] Enable opaque pointers in LLVM conversion passes by default"

This reverts commit cdd914a959528cd7abf36c096b4a0644c1721214.

[Test] Rename some negative tests into positive with required freeze

In fact, we can optimize this cases, it will just take us insertion of freeze.

[mlir][GPUToLLVM] Fix regression introduced with opaque-pointers when generate GPU launch func parameters

This has caused build failures when enabling opaque pointers for the GPU integration tests as could be seen here:
https://lab.llvm.org/buildbot/#/builders/220/builds/16946 and here https://lab.llvm.org/buildbot/#/builders/61/builds/40822

The gist of the issue was the use of a wrong pointer base type within a GEP. There sadly was no test coverage for either the generating of that GEP, nor is LLVM Dialects GEP verifier currently capable of catching such issues, so it went unnoticed until the integration tests actually attempted to convert it to LLVM IR.

Differential Revision: https://reviews.llvm.org/D145774

[InstSimplify] Adjust context instruction when threading phi (PR61312)

When threading operations over phis, we need to adjust the context
instruction to the terminator of the incoming block. This was
handled when threading icmps, but not when threading binops.

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

[InstSimplify] Add test for PR61312 (NFC)

[Clang][Sema] Start fixing handling of out-of-line definitions of constrained templates

This diff starts fixing our handling of out-of-line definitions of constrained templates.
Initially it was motivated by https://github.com/llvm/llvm-project/issues/49620 and
https://github.com/llvm/llvm-project/issues/60231.
In particular, this diff adjusts Sema::computeDeclContext to work properly in the case of
constrained template parameters.

Test plan:
1/ ninja check-all
2/ Bootstrapped Clang passes all the tests
3/ Internal testing

Differential revision: https://reviews.llvm.org/D145034

[InstCombine] Add precommit tests for strong order compare patterns; NFC

[llvm][Uniformity] consistently handle always-uniform instructions

An instruction that is "always uniform" is so even if it occurs in an
irreducible cycle. The output produced by such an instruction may depend on the
implementation defined cycle hierarchy, but that does not affect the uniformity
of the output. In other words, an "always uniform" instruction is uniform even
if it is not m-converged.

Reviewed By: ruiling, ronlieb

Differential Revision: https://reviews.llvm.org/D145572

[flang] Handle unlimited polymorphic with intrinsic dynamic type in extends_type_of

Unlimited polymorphic entities can have an intrinsic dynamic type. Update the
code of extends_type_of to compare the CFI_type in these case.

Reviewed By: PeteSteinfeld

Differential Revision: https://reviews.llvm.org/D145722

[Test] Add missing noundef in positive test

[RISCV] Use binary search for RISCVLoadFPImm::getLoadFPImm.

The table is sorted so we can use a binary search instead of a
linear scan.

Revert "[mlir] Enable opaque pointers in LLVM conversion passes by default"

This reverts commit 552522bef66c56dc4336d5948662f295dd733c0d.

There are test failures in integration tests for GPU builds

[mlir] Enable opaque pointers in LLVM conversion passes by default

Part of https://discourse.llvm.org/t/rfc-switching-the-llvm-dialect-and-dialect-lowerings-to-opaque-pointers/68179

When this patch lands any downstream users with custom LLVM conversion passes not yet using opaque pointers will start either experiencing assertions being triggered, null pointer dereferences or at the very least verifier errors. These can be either fixed by switching to opaque pointers or simply disabling opaque pointers in both pass options of any upstream conversion passes and any uses of `LLVMTypeConverter` via the `LowerToLLVMOptions`.

Users using just MLIRs conversion passes to the LLVM Dialect should not experience any change in functionality except when inspecting the output from the passes.

Differential Revision: https://reviews.llvm.org/D145585

[JITLink][docs] Update docs for generic link algorithm and memory manager apis.

These sections were out of date.

Revert "[NFC] Don't recompute Linkage for Decl in Release Modes"

This reverts commit 87ba95aa212a4fd363a4dd52677e9eea5224a4e7.

[NFC] Don't recompute Linkage for Decl in Release Modes

In the assertion enabled mode we will test if the computed linkage of
Declaration is consistent with the cached linkage. But we shouldn't
compuate it if we have cached linkage in the release modes.

[RISCV] Move some RISCVLoadFPImm out of line. NFC

This moves the LoadFPImmArr array to the cpp file. Being in the header
meant it was duplicated in every translation unit that includes the
header.

Move the 2 functions that use the array out of line.

[FSAFDO] Improve FS discriminator encoding

This change improves FS discriminators in the following ways:
(1) use call-stack debug information in the the to generate
discriminators: the same (src/line) DILs can now have same
discriminator value if they come from different call-stacks.
This effectively increases the usable discriminator values
for each round of FS discriminator pass.
(2) don't generate the FS discriminator for meta instructions
(i.e. instructions not emitted). This reduces the number
discriminators conflicts (for the case we run out of discriminator
bits for that pass).
(3) use less expensive hashing of xxHash64.

These improvements should bring better performance for FSAFDO
and they should be used by default. But this change creates
incompatible FS discriminators. For the iterative profile users,
they might see a performance drop in the first release with
this change (due to the fact that the profiles have the old
discriminators and the compiler uses the new discriminator).
We have measured that this is not more than 1.5% on several
benchmarks. Note the degradation should be gone in the second
release and one should expect a performance gain over the binary
without this change.

One possible solution to the iterative profile issue would be
separating discriminators for profile-use and the ones emitted to
the binary. This would require a mechanism to allow two sets of
discriminators to be maintained and then phasing out the first
approach. This is too much churn in the compiler and the
performance implications do not seem to be worth the effort.

Instead, we put the changes under an option so iterative profile
users can do a gradual rollout of this change. We will make the
option default value to true in a later patch and eventually
purge this option from the code base.

Differential Revision: https://reviews.llvm.org/D145171

[C++20] [Modules] Don't load declaration eagerly for named modules

Close https://github.com/llvm/llvm-project/issues/61064.

The root cause of the issue is that we will deserilize some declarations
eagerly when reading the BMI. However, many declarations in the BMI are
not necessary for the importer. So it wastes a lot of time.

[libfuzzer] Fix build error due to out-of-line definition of 'Fuzzer' does not match any declaration in 'fuzzer::Fuzzer' (NFC)

/data/llvm-project/compiler-rt/lib/fuzzer/FuzzerLoop.cpp:138:9: error: out-of-line definition of 'Fuzzer' does not match any declaration in 'fuzzer::Fuzzer'
Fuzzer::Fuzzer(UserCallback CB, InputCorpus &Corpus, MutationDispatcher &MD,
        ^~~~~~
/data/llvm-project/compiler-rt/lib/fuzzer/FuzzerInternal.h:35:10: note: type of 4th parameter of member declaration does not match definition ('fuzzer::FuzzingOptions &' vs 'const fuzzer::FuzzingOptions &')
         FuzzingOptions &Options);
         ^
1 error generated.

[Test] Add some corner cases negative tests for D143726

- No common loop-variant;
- One comparison against loop-variant;

[Test] Add negative and positive tests with extra uses for D143726

[Test] Add negative eq/ne tests for D143726

[Test] Add negative and positive mismatched predicates tests for D143726

[Test] Add negative and positive logical or/and tests for D143726

[Test] Add swapped tests for D143726

[libfuzzer] avoid unneccessary copy

Avoid some unneccessary copy

Reviewed By: fmayer

Differential Revision: https://reviews.llvm.org/D145758

[CodeGen][AArch64] Generate Pseudo instructions for integer MLA/MAD/MLS/MSB

Differential Revision: https://reviews.llvm.org/D145488

[Test] Regenerate tests using update_llc_test_checks.py

[JITLink] Use unique_function rather than std::function for JITLink passes.

Passes aren't expected to be copied, and switching to unique_function allows
them to capture values with move-only types.

[mlir] Add support for f8 data types to LLVM dialect types

This change allows using fp8 pointers when exporting to LLVM, because we anyway export them as opaque pointers, however full support of fp8 types is not yet implemented on the LLVM side.

Differential Revision: https://reviews.llvm.org/D143008

[HIP] Fix temporary files

Currently HIP toolchain uses Driver::GetTemporaryDirectory to
create a temporary directory for some temporary files during
compilation. The temporary directories are not automatically
deleted after compilation. This slows down compilation
on Windows.

Switch to use GetTemporaryPath which only creates temporay
files which will be deleted automatically.

Keep the original input file name convention for Darwin host
toolchain since it is needed for deterministic binary
(https://reviews.llvm.org/D111269)

Fixes: SWDEV-386058

Reviewed by: Artem Belevich

Differential Revision: https://reviews.llvm.org/D145509

[lld][WebAssembly] Use C++17 nested namespace syntax in most places. NFC

Like D131405, but for wasm-ld.

Differential Revision: https://reviews.llvm.org/D145399

[Codegen][NFC] Replace 'RegisterRegAlloc::FunctionPassCtor'
with 'RegisterRegAllocBase<T>::FunctionPassCtor'.

Reviewed By: arsenm

Differential Revision: https://reviews.llvm.org/D145032

[RISCV] Set how many bytes load from or store to stack slot

Refer from: https://reviews.llvm.org/D44782

After https://reviews.llvm.org/D130302, LW+SEXT.B can be folded into LB
as partially reload stack slot. This gains incorrect optimization result
from `StackSlotColoring` without given the number of bytes exactly load
from stack. LB+SW are mis-interpreted as fully reload/restore from stack
slot without the sign-extension. SW would be considered as a redundant store.

The testcase is copied from llvm/test/CodeGen/X86/pr30821.mir.

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D145471

[RISCV] Pre-commit test case for D140460

Reviewed By: craig.topper

Differential Revision: https://reviews.llvm.org/D145549

[ConstraintElimination] Fix UB after D145677

[libc++][ranges] Implement LWG-3865 Sorting a range of pairs

Reviewed By: Mordante, philnik, ldionne, #libc

Differential Revision: https://reviews.llvm.org/D144262

[RISCV] Model interleave and deinterleave shuffles in cost model

Interleave and deinterleave shuffles are lowered by a more efficient
sequence if the element size is smaller than ELEN.

Reviewed By: reames

Differential Revision: https://reviews.llvm.org/D145678

[HWASAN][LSAN] Fix buildbot failure.

[SVE] Precommit multiuse predicated compare tests.

[HWASAN][LSAN] Disable tests which don't pass in HWASAN+LSAN mode

Reviewed By: vitalybuka

Differential Revision: https://reviews.llvm.org/D145727

[lldb][InstrumentationRuntime] Make 'data' struct anonymous in order to avoid collisions with types in the debuggee

The `UBSAN`/`ASAN` plugins would previously call the internal helper
structure injected into the source expression `struct data { ... };`

This occasionally collided with user-defined types of the same (quite
common) name. In the presence of varibale with the same name LLDB would
simply fail to run the injected `InstrumentationRuntime` expressions
with:
```
warning: cannot evaluate AddressSanitizer expression:
expression failed to parse:
error: <user expression 2>:2:5: must use 'struct' tag to refer to type 'data' in this scope
    data t;
```

In the presence of another type called 'data', LLDB would most likely
crash with something like:
```
0x00000001198de614 clang::ASTNodeImporter::ImportDeclContext(clang::DeclContext*, bool) + 1088
0x00000001198de614 clang::ASTNodeImporter::ImportDeclContext(clang::DeclContext*, bool) + 1088
0x0000000119907930 clang::ASTImporter::ImportDefinition(clang::Decl*) + 596
0x00000001163db928 lldb_private::ClangASTImporter::ASTImporterDelegate::ImportDefinitionTo(clang::Decl*, clang::Decl*) + 100
0x00000001163da070 (anonymous namespace)::CompleteTagDeclsScope::~CompleteTagDeclsScope() + 572
...
```
...because it got the types confused.

This patch makes these structures anonymous so there's no
chance of clashing with other types in the program. This is
already the approach taken in `UBSan/InstrumentationRuntimeABSan.cpp`.

**Testing**

- API tests still pass
- Tested manually that the `memory history` command now works in the presence of a local called `data`

Differential Revision: https://reviews.llvm.org/D145569

[InstCombine] Reduce absolute diff from min+max+sub

This patch implements fold: max(a,b) nsw/nuw - min(a,b) --> abs(a nsw - b)

Alive2: https://alive2.llvm.org/ce/z/4yLp7D
Fixes: https://github.com/llvm/llvm-project/issues/61228

Signed-off-by: Jun Zhang <jun@junz.org>
Differential Revision: https://reviews.llvm.org/D145540

[llvm-c] Remove pointee support from LLVMGetElementType

Reviewed By: nikic

Differential Revision: https://reviews.llvm.org/D145717

[RISCV][NFC] Add tests for SLP vectorization of math functions

RISCV has "vfabs.v" and "vfsqrt.v" so math functions abs and sqrt
can be SLP vectorized. But others exp/log/sin/asin/sinh/asinh/...
can not.

Reviewed By: reames

Differential Revision: https://reviews.llvm.org/D145562

Break circular dependency between FIR dialect and utilities

[mlir][vector] remove unnecessary VectorTransformOps include

While at it, add a dep that we missed in https://reviews.llvm.org/D145638.

Reviewed By: kuhar, dcaballe

Differential Revision: https://reviews.llvm.org/D145731

Slight refinement to a change yesterday in metadata-added binaries

When ObjectFileMachO::LoadCoreFileImages load a binary into the
target with a valid load address, we don't need to re-load its
segments into the Target's SectionLoadList again.  But we should
still call ModulesDidLoad on these modules so breakpoints can be
inserted etc.

[Coroutines] Fix premature conversion of return object

Fix https://github.com/llvm/llvm-project/issues/56532

Effectively, this reverts behavior introduced in https://reviews.llvm.org/D117087,
which did two things:

1. Change delayed to early conversion of return object.
2. Introduced RVO possibilities because of early conversion.

This patches fixes (1) and removes (2). I already worked on a follow up for (2)
in a separated patch. I believe it's important to split these two because if the RVO
causes any problems we can explore reverting (2) while maintaining (1).

Notes on some testcase changes:
- `pr59221.cpp` changed to `-O1` so we can check that the front-end honors
  the value checked for. Sounds like `-O3` without RVO is more likely
  to work with LLVM optimizations...
- Comment out delete members `coroutine-no-move-ctor.cpp` since behavior
  now requires copies again.

Differential Revision: https://reviews.llvm.org/D145639

[scudo] Add a fast get time version.

On Android, the _COARSE version of clock_gettime is about twice as fast.
Therefore, add a getMonotonicTimeFast function that is used in the
releaseToOSMaybe functions.

Reviewed By: Chia-hungDuan

Differential Revision: https://reviews.llvm.org/D145636

[ORC] Fix name shadowing issue, NFC.

Testing the COFFPlatform on MSVC, a name shadowing issue surfaced where `LoadDynLibrary` inside the constructor was actually using the moved-from function argument. This patch simply renames the argument to avoid that shadowing.

Reviewed By: rriddle

Differential Revision: https://reviews.llvm.org/D145710

[sparse][mlir] test transposition on sorted COO

DO NOT SUBMIT YET, test exposes bug

Reviewed By: Peiming

Differential Revision: https://reviews.llvm.org/D145708