Please ref: #73668 for test coverage

While 0b80288e allowed more efficient lowering for 16xi8 loads, its
test case was closer to an "integration" one. Add a much simpler unit
test case that exercises it.

In preparation for handling non-assume context-sensitive facts.

It is quite common to symlink clang-format-diff.py to clang-format-diff,
and in that case the help output still refers to the .py version.
Compute it instead to work in both setup.

We only handle not for the top level value of the condition, so
move it there instead of trying to look through not at all leafs.
Also remove bitcast handling entirely -- we don't do anything
special wrt bitcasts, this is probably a leftover from pointer
types.

Fixed #72231

Ensure that block types get represented correctly in declaration
fragments, as block parameter names are important for documentation
clients we need a separate system from getFragmentsForType in order to
have access to full ParmVarDecls for the parameters.

rdar://118257401

… member functions

Implement the resolution to CWG2789 from
https://wiki.edg.com/pub/Wg21kona2023/StrawPolls/p3046r0.html

The DR page is not updated because the issue has not made it to a
published list yet.

The LD1 immediate offset instructions have both a pseudo and a real
instruction, mostly as the instructions shares a tablegen class with the
FFR version of the instructions. As far as I can tell the pseudo for the
non-ffr versions does not serve any useful purpose though, and we can
rejig the the classes to only define the pseudo for FFR instructions
similar to the existing sve_mem_cld_ss instructions.

The end result of this is that we don't have a SideEffects flag on the
LD1_IMM instructions whilst scheduling them, and have a few less pseudo
instructions which is usually a good thing.

Call computeKnownBits() with SimplifyQuery to make sure it gets
all available analyses, even if more are added in the future.

As this code is performance-critical, I'm exporting the variant
with by-ref KnownBits and SimplifyQuery, as the variant returning
KnownBits is measurably slower in this context.

If you need this, use one of the variants returning KnownBits
instead.

b/c it's used for element that folds a load, store or broadcast.

Silences a clang-format warning

This appears to have caused a variety of breakages, see comments on the PR.

> Summary:
> There are a few default options that LLVM adds that can be problematic
> for runtimes builds. These options are generally intended to handle
> building LLVM itself, but are also added when building in a runtimes
> mode. One such issue I've run into is that in `libc` we deliberately use
> `--target` to use a different device toolchain, which doesn't support
> some linker arguments passed via `-Wl`. This is observed in
> https://github.com/llvm/llvm-project/pull/73030 when attempting to use
> these options.
>
> This patch completely removes these default arguments.
>
> The consensus is that any issues created by this patch should ultimately
> be solved on a per-runtime basis.

This reverts commit ee922e6e.

This helps avoid a diff in #71764

Part of fixes for #72913.

clang emits `DW_AT_alignment` attribute, however LLDB didn't respect it,
resulting in incorrect RecordDecls built by lldb.

This only fixes non-inheritance cases. The inheritance case will be
handled in a follow-up patch.

1. Rename the names of tables to simplify the print
2. Align the abbreviation in the same file Instr -> Inst
3. Clang-format
4. Capitalize the first char of the variable name

Fixes #73628

This change is addressing case where alloca size is the same as
load/store size.

Split MatchDataInfo, CXXPredicates and the Pattern hierarchy into their
own files.

This should help with maintenance a bit, and make the API easier to
navigate.
I hope this encourages a bit more experimentation with MIR patterns,
e.g. I'd like to try getting them in ISel at some point.

Currently, this is pretty much only moving code around. There is no
significant refactoring in there.
I want to split the Combiner backend even more at some point though,
e.g. by separating the TableGen parsing logic into yet another file so
other backends could very easily parse patterns themselves.

Note: I moved the responsibility of managing string lifetimes into the
backend instead of the Pattern class.
e.g. Before you'd do `P.addOperand(Name)` but now it's
`P.addOperand(insertStrRef(Name))`.
I verified this was done correctly by running the tests with UBSan/ASan.

We were casting the LoadSDNode from the wrong node in the base pointer uses list, meaning the ptr/chain comparison were comparing against themselves.

arm64-apple-macosx is the default triple (usually with the macOS version
number) on arm64 macOS. Support it in update_llc_test_checks.py.

* Add a LinAlg pass to convert 2D convolutions and quantized 2D
convolutions that have the `FHWC` filter channel ordering into a
transpose followed by 2D convolutions that have the `HWCF` channel
ordering.

* Add a lit test to check the semantics of the transformation are
correct for both quantized and unquantized variants.

Signed-off-by: Jack Frankland <jack.frankland@arm.com>

...and follow ups.

As it has caused test failures on Linux Arm and AArch64:
https://lab.llvm.org/buildbot/#/builders/96/builds/49126
https://lab.llvm.org/buildbot/#/builders/17/builds/45824

```
  lldb-shell :: Subprocess/clone-follow-child-wp.test
  lldb-shell :: Subprocess/fork-follow-child-wp.test
  lldb-shell :: Subprocess/vfork-follow-child-wp.test
```

This reverts commit a6c62bf1,
commit a0a1ff3a and commit
fc6b7252.

Launch/stopped ordering was fixed by bd8f1068
but the Windows on Arm bot wasn't running at the time it landed.

The UTC output has changes slightly, regenerate tests to minimize
future diff.

This is needed after 225648e9

Co-authored-by: PaperChalice <example@example.com>

A splat packed constant can be folded as an inline immediate but it
shall use opsel. On gfx940 this code path can be skipped due to HW bug
workaround and then it may be folded w/o opsel which is a bug. Fixed.

The indexed compare fold converts comparisons of GEPs with same
(indirect) base into comparisons of offset. Currently, it only supports
GEPs with the same source element type.

This change makes the transform operate on offsets instead, which
removes the type dependence. To keep closer to the scope of the original
implementation, this keeps the limitation that we should only have at
most one variable index per GEP.

This addresses the main regression from
https://github.com/llvm/llvm-project/pull/68882.

TBH I have some doubts that this is really a useful transform (at least
for the case where there are extra pointer users, so we have to
rematerialize pointers at some point). I can only assume it exists for a
reason...

Store the ReverseChildren using node indices instead of node pointers.
This avoids some more hash table lookups.

I've also increased the size of the SmallVector from 2 to 4. As the
indices are half as large as the pointers (on 64bit) this keeps memory
usage the same as before. I've found the larger SmallVector to perform a
bit better.

This reverts commit 344b5346.
92b821f2 relanded in 04072485.

This reverts commit aaae104e.

This reverts commit 934efd2c.

This relands commit 1449b349.

This build system fix was reverted as the underlying patch that required
the fix got reverted due to test failures on Darwin. The test failures
have since been fixed and the patch has relanded, so we need support in
Bazel again.

This PR suggests a way to fix
https://github.com/llvm/llvm-project/issues/70418. It now throws an
error if the `index` operand for `memref.dim` is out of bounds. Catching
it in the verifier was not possible because the constant value is not
yet available at that point. Unfortunately, the error is not very
descriptive since it was only possible to propagate boolean up.