`affine::replaceForOpWithNewYields` and `replaceLoopWithNewYields` (for
"scf.for") are now interface methods and additional loop-carried
variables can now be added to "scf.for"/"affine.for" uniformly. (No more
`TypeSwitch` needed.)

Note: `scf.while` and other loops with loop-carried variables can
implement `replaceWithAdditionalYields`, but to keep this commit small,
that is not done in this commit.

Looke like a typo intoduced 7a36e612.

This patch promotes fmaximum/fminimum for fp16 vector to float
operation.

Not needed after 40781944.

Fixes internal_symbolizer tests with globals on aarch64.

Breaks https://lab.llvm.org/buildbot/#/builders/77/builds/30880

This reverts commit 58f75433.

We add a third argument `step` to `!range` bang operator to make it
with the same semantics as `range` in Python.

`step` can be negative. `step` is 1 by default and `step` can't be
0. If `start` < `end` and `step` is negative, or `start` > `end`
and `step` is positive, the result is an empty list.

Replaced TT_AttributeParen with TT_AttributeLParen and
TT_AttributeRParen.

There is an ABI incompatibility between clang and gcc that is unfortunate and
has bitten users multiple times already.

Fixes #62918

This patch implements the promotion of fp16 vectors SETCC and VP_SETCC
when we only have zvfhmin but no zvfh.

It was built and tested on x86_64 without real HWASAN tagging.

Some entrypoints supporting LLDB process introspection were not
being forwarded to asan_abi_foo() stable ABI entrypoints which
effectively dead-ended them in NOPs that could not be implemented
by Stable ABI.

rdar://115974403

Reviewed By: wrotki, vitalybuka, MaskRay

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

This reverts commit 32db121b and subsequent commits.

This causes time regression on llvm-cov even with debug info correlation off.

This will affect only Darwin, as the rest alredy do that.

Reviewed By: rsundahl

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

This patch makes clang diagnose extensive cases of consteval if and is_constant_evaluated usage that are tautologically true or false.
This introduces a new IsRuntimeEvaluated boolean flag to Sema::ExpressionEvaluationContextRecord that means the immediate appearance of if consteval or is_constant_evaluated are tautologically false(e.g. inside if !consteval {} block or non-constexpr-qualified function definition body)
This patch also pushes new expression evaluation context when parsing the condition of if constexpr and initializer of constexpr variables so that Sema can be aware that the use of consteval if and is_consteval are tautologically true in if constexpr condition and constexpr variable initializers.
BEFORE this patch, the warning for is_constant_evaluated was emitted from constant evaluator. This patch moves the warning logic to Sema in order to diagnose tautological use of is_constant_evaluated in the same way as consteval if.

This patch separates initializer evaluation context from InitializerScopeRAII.
This fixes a bug that was happening when user takes address of function address in initializers of non-local variables.

Fixes https://github.com/llvm/llvm-project/issues/43760
Fixes https://github.com/llvm/llvm-project/issues/51567

Reviewed By: cor3ntin, ldionne
Differential Revision: https://reviews.llvm.org/D155064

Followup to #67491

Bug introduced in https://reviews.llvm.org/D153775

common.itertests has useful functionality such as skipping test case if
it starts with UTC_AVOID comment string. It also does some of the
functionality, such as skipping test file pattern if not found, that was
duplicated by update_mca_test_checks.

This patch uses this function to take advantage of extra behavior and
remove duplication.

This prevent users from being subscribed automatically to draft pull
requests.

I accidentally introduced this in

commit 330fa7d2 ("[TargetLowering] Deduplicate choosing InlineAsm
constraint between ISels (#67057)")

Fix forward.

__sanitizer_symbolize_frame is used by HWASAN
for use after scope reports.

This PR is a breakdown of the big PR
https://github.com/llvm/llvm-project/pull/65539 which enables intel gpu
integration. In this PR we pass hostShared flag to runtime wrappers
(required by SyclRuntimeWrappers which will come in subsequent PR) to
indicate if the allocation is done on host shared gpu memory or device
only memory.

I'm looking to update this test; pre-processing it with
update_llc_test_checks.py makes it clearer what I'm changing in #20571.

`ignoreAutoLinkOptions` checks run both in `parseLCLinkerOptions` and
`resolveLCLinkerOptions`. Convert the latter check to an assert.

Not sure if xor is sticking around or not. I see and/or was already
removed.

This changes the error messages and makes one error message more
accurate.

This can lead to build failure when a project is customizing this flag
for TableGen. This seems to have been copy/pasted from TableGen CMake
functions.

Fixed #67407.

- Now that the KHR coop matrix implementation is robust, switch the gpu
conversion pass to default to it.
- Use a populate function for MMA to coop matrix type conversions. This
makes the API surface area smaller.

Fixes #66857.

Summary:
Currently, we use the RPC server to respond to different ports which
each contain a request from some client thread wishing to do work on the
server. This scan starts at zero and continues until its checked all
ports at which point it resets. If we find an active port, we service it
and then restart the search.

This is bad for two reasons. First, it means that we will always bias
the lower ports. If a thread grabs a high port it will be stuck for a
very long time until all the other work is done. Second, it means that
the `handle_server` function can technically run indefinitely as long as
the client is always pushing new work. Because the OpenMP implementation
uses the user thread to service the kernel, this means that it could be
stalled with another asyncrhonous device's kernels.

This patch addresses this by making the server restart at the next port
over. This means we will always do a full scan of the ports before
quitting.

Summary:
The RPC server is responsible for providing host services from the GPU.
Generally, the client running on the GPU will spin in place until the
host checks the server. Inside the runtime, we elected to have the user
thread do this checking while it would be otherwise waiting for the
kernel to finish. However, for Nvidia this caused problems when
offloading to a target region that requires a copy back.

This is caused by the implementation of `dataRetrieve` on Nvidia. We
initialize an asynchronous copy-back on the same stream that the kernel
is running on. This creates an implicit sync on the kernel to finish
before we issue the D2H copy, which we then wait on. This implicit sync
happens inside of the CUDA runtime. This is problematic when running the
RPC server because we need someone to check the RPC server. If no one
checks the RPC server then the kernel will never finish, meaning that
the memcpy will never be issued and the program hangs. This patch adds
an explicit check for unfinished work on the stream and waits for it to
complete.

For all the mlir tests (except for roundtrip_coding.mlir), change the
check test to use general form of encoding
`#sparse_tensor.encoding<{{{.*}}}>` instead of actual encoding such as
`#sparse_tensor.encoding<{ lvlTypes = [ "compressed", "singleton" ] }>`.

To make DWARFDebugAbbrev more amenable to error-handling, I would like
to change the return type of DWARFDebugAbbrev::parse from `void` to
`Error`. Users of DWARFDebugAbbrev can consume the error if they want to
use all the valid DWARF that was parsed (without worrying about the
malformed DWARF) or stop when the parse fails if the use case needs to
be strict.

This also will bring the LLVM DWARFDebugAbbrev interface closer to
LLDB's which opens up the opportunity for LLDB adopt the LLVM
implementation with minimal changes.

[mlir][TilingInterface] NFC code changes separated out from introduction of `scf::tileUsingSCFForallop`. (#67081)

This patch contains NFC changes that are precursor to the introduction
of `scf::tileUsingSCFForallOp` method introduced in
https://github.com/llvm/llvm-project/pull/67083.

Same change than #67368 but for the reduction recipe.

Makes outer level dense, so we get the common
block-column index way of storing blocks. Also
gives an example of a dim2lvl/lvl2dim map.