Revert "[Clang][AArch64][Darwin] Enable GlobalISel by default for Darwin ARM64 platforms."

This reverts commit f64802e8d3e9db299cad913ffcb734c8d35dc5f0.

Add a const version of SDUse::getUser [nfc]

Model UB in integer division operations in the arith dialect

Before this commit `arith.{ceil}div{u|s}i` were marked `Pure` which is
incorrect because these operations invoke UB on certain inputs.

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

Reviewed By: kuhar

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

[ObjectYAML] Basic support for chained fixups.

Add basic binary support for chained fixups. This allows basic tests
with chained fixups without trying to create a format for them until the
work on the Object library is considered finished.

Reviewed By: pete

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

Fix typo; NFC

Co-authored-by: Guillot Tony <tony.guillot@protonmail.com>

Revert "[LLDB] Devirtualize coroutine promise types for `std::coroutine_handle`"

This reverts commit 558db7787005348e2efaabb628ec36f1c461a741 due to
buildbot failures on ARM
* https://lab.llvm.org/buildbot/#/builders/96/builds/31416
* https://lab.llvm.org/buildbot/#/builders/17/builds/30086

[NFC][AArch64]Call encoding functions for left-shift immediate (which is no-op in terms of value but better code style)

Call encoding functions for left-shfit immidate for consistency (and
easier tracking if the encoding ever changes in the future).

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

[mlir][sparse] Extend more integration to run on the codegen path.

Reviewed By: Peiming

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

[X86] Split int2double and float2double scheduler classes on Haswell/Broadwell to remove overrides

Haswell/Broadwell have numerous conversion instructions that use different scheduler pipes for the reg-reg and reg-mem variants (and not an additional Port23 uop for memory folding) - so declare the classes separately instead of using the HWWriteResPair/BWWriteResPair helpers

[LLDB] Devirtualize coroutine promise types for `std::coroutine_handle`

This commit teaches the `std::coroutine_handle` pretty-printer to
devirtualize type-erased promise types. This is particularly useful to
resonstruct call stacks, either of asynchronous control flow or of
recursive invocations of `std::generator`. For the example recently
introduced by https://reviews.llvm.org/D132451, printing the `__promise`
variable now shows

```
(std::__coroutine_traits_sfinae<task, void>::promise_type) __promise = {
  continuation = coro frame = 0x555555562430 {
    resume = 0x0000555555556310 (a.out`task detail::chain_fn<1>() at llvm-nested-example.cpp:66)
    destroy = 0x0000555555556700 (a.out`task detail::chain_fn<1>() at llvm-nested-example.cpp:66)
    promise = {
      continuation = coro frame = 0x5555555623e0 {
        resume = 0x0000555555557070 (a.out`task detail::chain_fn<2>() at llvm-nested-example.cpp:66)
        destroy = 0x0000555555557460 (a.out`task detail::chain_fn<2>() at llvm-nested-example.cpp:66)
        promise = {
          ...
        }
      }
      result = 0
    }
  }
  result = 0
}
```

(shortened to keep the commit message readable) instead of

```
(std::__coroutine_traits_sfinae<task, void>::promise_type) __promise = {
  continuation = coro frame = 0x555555562430 {
    resume = 0x0000555555556310 (a.out`task detail::chain_fn<1>() at llvm-nested-example.cpp:66)
    destroy = 0x0000555555556700 (a.out`task detail::chain_fn<1>() at llvm-nested-example.cpp:66)
  }
  result = 0
}
```

Note how the new debug output reveals the complete asynchronous call
stack: our own function resumes `chain_fn<1>` which in turn will resume
`chain_fn<2>` and so on. Thereby this change allows users of lldb to
inspect the logical coroutine call stack without using any custom debug
scripts (although the display is still a bit clumsy. It would be nicer
to also integrate this into lldb's backtrace feature, but I don't know
how to do so)

The devirtualization currently works by introspecting the function
pointed to by the `destroy` pointer. (The `resume` pointer is not worth
much, given that for the final suspend point `resume` is set to a
nullptr. We have to use the `destroy` pointer instead.) We then look
for a `__promise` variable inside the `destroy` function. This
`__promise` variable is synthetically generated by LLVM, and looking at
its type reveals the type-erased promise_type.

This approach only works for clang-generated code, though. While gcc
also adds a `_Coro_promise` variable to the `resume` function, it does
not do so for the `destroy` function. However, we can't use the `resume`
function, as it will be reset to a nullptr at the final suspension
point. For the time being, I am happy with de-virtualization only working
for clang. A follow-up commit will further improve devirtualization and
also expose the variables spilled to the coroutine frame. As part of
this, I will also revisit gcc support.

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

AMDGPU: Disable some class simplifications for strictfp

[mlir][sparse] Fix a bug in rewriting dense2dense convert op.

Permutation wasn't handled correctly. Add a test for the rewriting.

Extend an integration test to run with enable_runtime_library=false to
also test the rewriting.

Reviewed By: Peiming

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

consistency: use spaces instead of tabs

[NFC] Remove unused OrigLoopID vars

[LV] Remove unused OrigLoopID argument from completeLoopSekelton (NFC).

The argument is not used any longer and can be removed.

Precommit for redundant and after SVE load

The handling of 'funsafe-math-optimizations' doesn't update the 'MathErrno'
flag. But the driver checks for 'fno-math-errno' before passing
'funsafe-math-optimizations' to the FE. In GCC, the option
'funsafe-math-optimizations' doesn't affect the 'fmath-errno' flag.
This patch aligns clang with GCC.

'-ffast-math' sets the FPContract to 'fast'. But 'funsafe-math-optimizations'
the driver doesn't consider the FPContract when handling the option.
Unfortunately there are places in the BE that interpret unsafe math
mode as allowing FMA. This patch makes -ffast-math' and
'funsafe-math-optimizations' behave similarly in regard to the setting of the
FPContract.

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

[X86] Replace unnecessary CVTPS2DQ folded overrides with better base class defs

Broadwell just needed the load latency to be tweaked for the overrides to be unnecessary - I think this was due to Issue #38536 (underestimation of most broadwell load latencies)

[InstSimplify] add test for fsub with inf operand; NFC

Verify that constant negation works with a partial undef vector.
Also, remove a bogus TODO comment on a related test.

[MemCpyOpt] Avoid moving lifetime marker above def (PR58903)

This is unlikely to happen with opaque pointers, so just bail out
of the transform, rather than trying to move bitcasts/etc as well.

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

[include-cleaner] NFC, move the macro location fixme to findHeaders.

[InstSimplify] fold fsub nnan with Inf operand

Similar to fbc2c8f2fbbb, but if we have a non-canonical
fsub with constant operand 1, then flip the sign of the
Infinity:
https://alive2.llvm.org/ce/z/vKWfhW

If Infinity is operand 0, then the sign remains:
https://alive2.llvm.org/ce/z/73d97C

[include-cleaner] NFC, correct a comment in
PragmaIncludes::RecordPragma.

[mlir][bufferize][NFC] Consolidate transform header files

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

[compiler-rt] Mark $t* as clobbered for Linux/LoongArch syscalls

Linux/LoongArch doesn't preserve temporary registers across syscalls,
so we have to explicitly mark them as clobbered to avoid trashing local variables.

Reviewed By: xry111, xen0n, tangyouling, SixWeining

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

for Vignesh: land changes to disable two recent ompd random fails

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

[clang-include-cleaner] make SymbolLocation a real class, move FindHeaders

- replace SymbolLocation std::variant with enum-exposing version similar to
  those in types.cpp. There's no appropriate implementation file, added
  LocateSymbol.cpp in anticipation of locateDecl/locateMacro.
- FindHeaders is not part of the public Analysis interface, so should not
  be implemented/tested there (just code organization)
- rename findIncludeHeaders->findHeaders to avoid confusion with Include concept

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

[Clang][LoongArch] Remove duplicate declaration. NFC

[include-cleaner] Provide public to_string of RefType (for HTMLReport), clean up includes. NFC

[openmp] [test] Set the right calling convention for the Windows thread start function

This is required on i386 Windows; this fixes 99 testcases in that
build configuration.

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

[openmp] [test] Use omp_testsuite.h instead of directly including pthread.h

OpenMP tests that use pthread functions include this header instead.
On Unix systems, this header includes pthread.h, while it provides
minimal implementations of the used pthread functions for Windows.

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

[openmp] [test] Fix building the affinity/format/fields_values.c testcase on Windows

Add a missing <process.h> include for _getpid. Don't typedef the
pid_t type on mingw, as mingw headers already provide a typedef for
it.

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

[openmp] Fix building in debug mode with mingw

Mingw doesn't provide the _malloc_dbg/_free_dbg functions.

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

[include-cleaner] verbatimSpelling->verbatim, clean up some silly init-lists. NFC

[mlir] Fix asan errors in gpu transform dialect

[mlir][bufferize] Eliminate tensor.empty ops instead of bufferization.alloc_tensor ops

tensor.empty op elimination is an optimization that brings IR in a more bufferization-friendly form. E.g.:

```
%0 = tensor.empty()
%1 = linalg.fill(%cst, %0) {inplace = [true]}
%2 = tensor.insert_slice %1 into %t[10][20][1]
```

Is rewritten to:

```
%0 = tensor.extract_slice %t[10][20][1]
%1 = linalg.fill(%cst, %0) {inplace = [true]}
%2 = tensor.insert_slice %1 into %t[10][20][1]
```

This optimization used to operate on bufferization.alloc_tensor ops. This is not correct because the documentation of bufferization.alloc_tensor says that it always bufferizes to an allocation. Instead, this optimization should operate on tensor.empty ops, which can then be lowered to bufferization.alloc_tensor ops (if they don't get eliminated).

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

[LoongArch] Generate PCALAU12I + JIRL instruction pair for medium codemodel

In LoongArch, when `CodeModel=Medium`, it just increases the jumping
ability of function calls relative to PC, from 2^28 to 2^32.

Depends on D137393

Reviewed By: SixWeining

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

[AMDGPU][MC] Disable SGPRs as src operands of VOP3 VINTRP instructions

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

[LoongArch] Moved expansion of PseudoCALL to LoongArchPreRAExpandPseudo pass

This patch moves the expansion of the `PseudoCALL` insturction to
`LoongArchPreRAExpandPseudo` pass. This helps to expand into different
instruction sequences according to different CodeModels.

Reviewed By: SixWeining

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

[Hexagon] Use default attributes for intrinsics

This switches Hexagon intrinsics to use the default attributes
(nosync, nofree, nocallback and willreturn). Especially willreturn
is needed to prevent optimization regressions in the future.

The only intrinsics I've excluded here are the load/store locked
intrinsics, which presumably aren't nosync.

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

Revert "Revert "[mlir][linalg] Replace "string" iterator_types attr with enums in LinalgInterface.""

With python code fixed.

This reverts commit 41280908e43d47903960c66237ab49caa5641b4d.

[mlir] Fix forward the fix for incorrect Optional<ArrayAttr> usage.

[Test] Add test for crash in IRCE when IV is AddRec for another loop

This adds a test for https://github.com/llvm/llvm-project/issues/58912.
IRCE crashes when it tries to check whether it is possible to safely
calculate the bounds of a loop with IV AddRec which is in another loop.

[mlir] Fix incorrect access to the Optional<ArrayAttr> underlying values.

[include-cleaner] Initial version for the "Location=>Header" step

This patch implements the initial version of "Location => Header" step:

- define the interface;
- integrate into the existing workflow, and use the PragmaIncludes;

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

[AArch64] Add smull sinking extract-and-splat tests and regenerate neon-vmull-high-p8.ll. NFC

[opt] Remove support for using -O[0|1|2|3|s|z] with legacy PM in opt

When running a default pipeline (for a specific O-level) in opt it is
now expected that the new PM should be used. Only reason to use the
legacy PM is when testing a pass that is locked to the legacy PM (or
when testing single passes, for example used by the llc backend).

If a test should run both a default pipeline plus some other passes,
the solution would be to invoke opt twice (separating the default
pipeline execution from the execution of individual passes).

Starting with this patch "opt -O0" etc. will result in an error.

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

[mlir] Introduce device mapper attribute for `thread_dim_map` and `mapped to dims`

`scf.foreach_thread` defines mapping its loops to processors via an integer array, see an example below. A lowering can use this mapping. However, expressing mapping as an integer array is very confusing, especially when there are multiple levels of parallelism. In addition, the op does not verify the integer array. This change introduces device mapping attribute to make mapping descriptive and verifiable. Then it makes GPU transform dialect use it.

```
scf.foreach_thread (%i, %j) in (%c1, %c2) {
scf.foreach_thread (%i2, %j2) in (%c1, %c2)
{...} { thread_dim_mapping = [0, 1]}
} { thread_dim_mapping = [0, 1]}
```

It first introduces a `DeviceMappingInterface` which is an attribute interface. `scf.foreach_thread` defines its mapping via this interface. A lowering must define its attributes and implement this interface as well. This way gives us a clear validation.

The change also introduces two new attributes (`#gpu.thread<x/y/z>` and `#gpu.block<x,y,z>` ). After this change, the above code prints as below, as seen here, this way clarifies the loop mappings. The change also implements consuming of these two new attribute by the transform dialect. Transform dialect binds the outermost loops to the thread blocks and innermost loops to threads.

```
scf.foreach_thread (%i, %j) in (%c1, %c2) {
scf.foreach_thread (%i2, %j2) in (%c1, %c2)
{...} { thread_dim_mapping = [#gpu.thread<x>, #gpu.thread<y>]}
} { thread_dim_mapping = [#gpu.block<x>, #gpu.block<y>]}
```

Reviewed By: ftynse, nicolasvasilache

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

[clang][Interp] Protect Record creation against infinite recursion

This happens only in error cases, but we need to handle it anyway.

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

[clang][Interp] Support alignof()

Support alignof() and __alignof() expressions.

Fixes #58816

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

[clang][Interp] DerivedToBase casts

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

Add builtin_elementwise_sin and builtin_elementwise_cos

Add codegen for llvm cos and sin elementwise builtins
The sin and cos elementwise builtins are necessary for HLSL codegen.
Tests were added to make sure that the expected errors are encountered
when these functions are given inputs of incompatible types.
The new builtins are restricted to floating point types only.

Reviewed By: craig.topper, fhahn

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

[OpenMP] [OMPD] Testcases for libompd

This is part of the OMPD Path set started from review.
https://reviews.llvm.org/D100181

Reviewed By: @jdoerfert, @dreachem

[RISCV] Remove unused CHECK lines from test. NFC

These aren't included in the check-prefixes.

[LangRef][LoongArch] Update inline asm constraint code and operand modifier

According to:
https://reviews.llvm.org/D134157
https://reviews.llvm.org/D136841
https://reviews.llvm.org/D136835

Reviewed By: SixWeining

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

AtomicExpand: Support cmpxchg expansion for small FP types

Handles f16 atomics for AMDGPU.

Avoid fallthrough after ffb109b6852d248c9d2e3202477dccf20aac7151

Fallthrough appears to be not intended here, as otherwise this is a completely dead store: `DOPRegIsUnique` will be overwritten by the next case.

[LTO] Make local linkage GlobalValue in non-prevailing COMDAT available_externally

For a local linkage GlobalObject in a non-prevailing COMDAT, it remains defined while its
leader has been made available_externally. This violates the COMDAT rule that
its members must be retained or discarded as a unit.

To fix this, update the regular LTO change D34803 to track local linkage
GlobalValues, and port the code to ThinLTO (GlobalAliases are not handled.)

This fixes two problems.

(a) `__cxx_global_var_init` in a non-prevailing COMDAT group used to
linger around (unreferenced, hence benign), and is now correctly discarded.
```
int foo();
inline int v = foo();
```

(b) Fix https://github.com/llvm/llvm-project/issues/58215:
as a size optimization, we place private `__profd_` in a COMDAT with a
`__profc_` key. When FuncImport.cpp makes `__profc_` available_externally due to
a non-prevailing COMDAT, `__profd_` incorrectly remains private. This change
makes the `__profd_` available_externally.

```
cat > c.h <<'eof'
extern void bar();
inline __attribute__((noinline)) void foo() {}
eof
cat > m1.cc <<'eof'
#include "c.h"
int main() {
  bar();
  foo();
}
eof
cat > m2.cc <<'eof'
#include "c.h"
__attribute__((noinline)) void bar() {
  foo();
}
eof

clang -O2 -fprofile-generate=./t m1.cc m2.cc -flto -fuse-ld=lld -o t_gen
rm -fr t && ./t_gen && llvm-profdata show -function=foo t/default_*.profraw

clang -O2 -fprofile-generate=./t m1.cc m2.cc -flto=thin -fuse-ld=lld -o t_gen
rm -fr t && ./t_gen && llvm-profdata show -function=foo t/default_*.profraw
```

If a GlobalAlias references a GlobalValue which is just changed to
available_externally, change the GlobalAlias as well (e.g. C5/D5 comdats due to
cc1 -mconstructor-aliases). The GlobalAlias may be referenced by other
available_externally functions, so it cannot easily be removed.

Depends on D137441: we use available_externally to mark a GlobalAlias in a
non-prevailing COMDAT, similar to how we handle GlobalVariable/Function.
GlobalAlias may refer to a ConstantExpr, not changing GlobalAlias to
GlobalVariable gives flexibility for future extensions (the use case is niche.
For simplicity we don't handle it yet). In addition, available_externally
GlobalAlias is the most straightforward implementation and retains the aliasee
information to help optimizers.

See windows-vftable.ll: Windows vftable uses an alias pointing to a
private constant where the alias is the COMDAT leader. The COMDAT use case
is skeptical and ThinLTO does not discard the alias in the non-prevailing COMDAT.
This patch retains the behavior.

Reviewed By: tejohnson

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

[RISCV] Use OPCFG format record for vsetvli in tablgen. NFC

Reviewed By: kito-cheng

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

[RISCV] Add OPCFG format of vector. NFC

Refer to https://github.com/riscv/riscv-v-spec/blob/master/v-spec.adoc#101-vector-arithmetic-instruction-encoding

Patch by Jiejie Rong

Reviewed By: reames

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

AMDGPU: Use generic is.fpclass enum instead of locally defined copy

The generic intrinsic uses the same bitlayout as the amdgcn intrinsic,
so re-use the enum.

[lldb/test] Fix app_specific_backtrace_crashlog.test (NFC)

This patch fixes app_specific_backtrace_crashlog.test.

It was failing because one of the loaded images was built with
optimization which added a new warning message between the first
`CHECK` and the `CHECK-NEXT`, breaking the expected ordering.

Signed-off-by: Med Ismail Bennani <medismail.bennani@gmail.com>

Revert "[LTO] Make local linkage GlobalValue in non-prevailing COMDAT available_externally"

This reverts commit 89ddcff1d2d6e9f4de78f3a563a8b1987bf7ea8f.

Reason: This breaks bootstrapping builds of LLVM on Windows using
ThinLTO; see https://crbug.com/1382839

[Clang][LoongArch] Implement __builtin_loongarch_crc_w_d_w builtin and add diagnostics

This patch adds support to prevent __builtin_loongarch_crc_w_d_w from compiling
on loongarch32 in the front end and adds diagnostics accordingly.

Reference: https://github.com/gcc-mirror/gcc/blob/master/gcc/config/loongarch/larchintrin.h#L175-L184

Depends on D136906

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

[AArch64][SVE] Support logical operation BIC with DestructiveBinary patterns

Logical operation BIC with DestructiveBinary patterns is temporarily removed as
causes an assert (commit 3c382ed71f15), so try to fix that.
The most significant being that for pseudo instructions that do not have real instructions (including movpfx'd ones) that cover all combinations of register allocation, their expansion will be broken. This is the main reason the zeroing is an experimental feature because it has known bugs.
So we add an extra LSL for movprfx expand BIC_ZPZZ_ZERO A, P, A, A when necessary.
  movprfx z0.s, p0/z, z0.s
  lsl z0.b, p0/m, z0.b, #0
  bic z0.s, p0/m, z0.s, z0.s

Depends on D88595

Add missing changes for "[Clang][LoongArch] Handle -march/-m{single,double,soft}-float/-mfpu options"

Some changes in D136146 were lost by an accidentally sumbit. So recover
them.

[mlir][vector] Add insertOp src shape check for BubbleUpBitCastForStridedSliceInsert

Not all shape of vectors can be casted into other types, we add a check
to not fold insertOp into bitcast if the shape does not support it.

Examples of unsupported shape castings are f16 vectors to f32 if the
shape is not multiple of 2s. or int8 to int32 if shapes are not multiple
of 4.

Reviewed By: antiagainst, ThomasRaoux

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

[libclang] Expose completion result kind in `CXCompletionResult`

This allows clients of libclang to check whether a completion result is a keyword. Previously, keywords had `CursorKind == CXCursor_NotImplemented` and it wasn't trivial to distinguish a keyword from a pattern.

This change moves `CodeCompletionResult::ResultKind` to `clang-c` under a new name `CXCompletionResultKind`. It also tweaks `c-index-test` to print the result kind instead of `NotImplemented`, and adjusts the tests for the new output.

rdar://91852088

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

Check m_dyld_up directly in LoadBinariesViaMetadata

In the restructuring I did in https://reviews.llvm.org/D133680 , I
call ObjectFile::LoadBinariesViaMetadata, and the process m_dyld
may be set by a method under there -- in
ProcessMachCore::LoadBinariesViaMetadata I wanted to check to see
if m_dyld_up had been set.  I did this by calling the GetDynamicLoader()
method, but that method will call FindPlugin() if there is no
dynamic loader yet, and the static dynamic loader plugin was being
loaded, preventing the scan for userland binaries in a userland
corefile.

Differential Revision: https://reviews.llvm.org/D137807
rdar://102210820

Apply clang-tidy fixes for readability-identifier-naming in TosaOps.cpp (NFC)

Apply clang-tidy fixes for performance-unnecessary-value-param in SparseTensorDialect.cpp (NFC)

[mlir][sparse] Fix a test to check all output coordinates.

Reviewed By: Peiming

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

Apparently I moved the wrong one to "2", then Jason moved the right
one, so this commit moves the wrong one back to no-"2"...

[SelectDagISEL] refactor HandlePHINodesInSuccessorBlocks NFC.

While working on this code to support outputs from callbr along indirect
branches, I kept making these changes again and again. Precommit these.

Reviewed By: craig.topper

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

[lld-macho] Set 4-byte alignment for `__init_offsets`

dyld refuses to run initializers if this section is unaligned.

Fixes https://bugs.chromium.org/p/chromium/issues/detail?id=1383240

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

[mlir][sparse] Fix a bug in rewriting for the convert op.

The code to retrieve the number of entries isn't correct.

Reviewed By: Peiming

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

[CodeGen][Test] simplify callbr-asm-outputs.ll with nounwind NFC

The CFI directives add noise to the test. Remove them via nounwind fn
attrs. Also remove clobbers.

Reviewed By: void

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

[Flang] Allow registering plugin extensions with the pass builder

Pass plugins are compiled and linked dynamically by default. Setting
`LLVM_${NAME}_LINK_INTO_TOOLS` to `ON` turns the project into a
statically linked extension. Projects like Polly can be used this way by
adding `-DLLVM_POLLY_LINK_INTO_TOOLS=ON` to the `cmake` command.

The changes in this patch makes the PassBuilder in Flang aware of
statically linked pass plugins, see the documentation for more details:
https://github.com/llvm/llvm-project/blob/main/llvm/docs/WritingAnLLVMNewPMPass.rst#id21

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

Change-Id: Id1aa501dcb4821d0ec779f375cc8e8d6b0b92fce

[InstSimplify] fold X +nnan Inf

If we exclude NaN (and therefore the opposite Inf),
anything plus Inf is Inf:
https://alive2.llvm.org/ce/z/og3dj9

[InstSimplify] add tests for fadd/fsub with inf constant operand; NFC

[lldb][test] TestConstStaticIntegralMember.py: fix for clang-{9,11,13}

**Summary**

The public lldb matrix bot is failing for tests compiled with clang-9, clang-11, clang-13.

This patch addresses these failures by evaluating the enum case that
doesn't cause malformed DWARF in older version of clang.

There was no particular reason we had to use `true` enum case
to reproduce the bug in #58383, so simply switch to use `false`
to get all bots passing again.

**Details**

In older versions of clang, the following snippet:
```
enum EnumBool : bool {
  enum_bool_case1 = false,
  enum_bool_case2 = true,
};

struct A {
  const static EnumBool enum_bool_val = enum_bool_case2;
};
```

…results in following DWARF:
```
0x00000052:   DW_TAG_structure_type
                DW_AT_calling_convention        (DW_CC_pass_by_value)
                DW_AT_name      ("A")
                DW_AT_byte_size (0x01)
                DW_AT_decl_file ("/Users/michaelbuch/Git/llvm-project/lldb/test/API/lang/cpp/const_static_integral_member/repro.cpp")
                DW_AT_decl_line (6)

0x0000005b:     DW_TAG_member
                  DW_AT_name    ("enum_bool_val")
                  DW_AT_type    (0x0000000000000068 "const EnumBool")
                  DW_AT_decl_file       ("/Users/michaelbuch/Git/llvm-project/lldb/test/API/lang/cpp/const_static_integral_member/repro.cpp")
                  DW_AT_decl_line       (7)
                  DW_AT_external        (true)
                  DW_AT_declaration     (true)
                  DW_AT_const_value     (-1)

```

Note the `DW_AT_const_value == -1`

When evaluating `A::enum_bool_val` in the lldb we get:
```
(lldb) p A::enum_bool_val
error: expression failed to parse:
error: Couldn't lookup symbols:
  __ZN1A13enum_bool_valE
```

Enabling the DWARF logs we see:

```
(arm64) clang-13.out: DWARFASTParserClang::ParseTypeFromDWARF (die = 0x00000068, decl_ctx = 0x136ac1e30 (die 0x0000000b)) DW_TAG_const_type name = '(null)')
Failed to add const value to variable A::enum_bool_val: Can't store unsigned value 18446744073709551615 in integer with 1 bits.
```

This occurs because a boolean enum is considered an unsigned integer
type, but we try to initialize it with a `-1`.

**Testing**

- Confirmed locally that top-of-tree lldb correctly
  evaluates the previously failing expression when
  the test program is compiled with clang-13

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

[clang-format][NFC] More sorting in getLLVMStyle()

Seems I've missed that.

Amends 41a09a07ce4ddd1e97ce0430d1debe1dcc853890

[clang-format] Add BreakBeforeInlineASMColon configuration

If true, colons in ASM parameters will be placed after line breaks.

true:
asm volatile("string",
                     :
                     : val);

false:
asm volatile("string", : : val);

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

cmake: Inline the add_llvm_symbol_exports.py script

This fixes stand-alone builds.

Reviewed By: andrewng

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

docs: Add instructions for stand-alone builds of clang

More sub-projects will be added to the table once they have been verified
to be buildable in stand-alone mode.

Reviewed By: MaskRay, mgorny

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

[InstCombine] PR58901 - fix bug with swapping GEP of different types

Fix https://github.com/llvm/llvm-project/issues/58901 by adding stricter check whether non-opaque GEP can be swapped. This will not affect GEP swapping optimization in the future since we are switching to opaque GEP

Reviewed By: clin1

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

[release] Add third-party tarball to release for standalone builds

With the advent of https://reviews.llvm.org/D131919 and
https://github.com/llvm/llvm-project/commit/a11cd0d94ed3cabf0998a0289aead05da94c86eb
 the third-party directory is required to build LLVM and other packages and in standalone
builds the third-party directory is not available from the llvm tarball anymore.

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

Updated contact email address.

[libc++] Documents details of the pre-commit CI.

This documentation aims to make it cleare how the libc++ pre-commit CI
works. For libc++ developers and other LLVM projects whose changes can
affect libc++.

This was discusses with @aaron.ballman as a follow on some unclearities
for the Clang communitee how the libc++ pre-commit CI works.

Note some parts depend on patches under review as commented in the
documentation.

Reviewed By: ldionne, #libc, philnik

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

[VectorCombine] widen a load with subvector insert

This adapts/copies code from the existing fold that allows
widening of load scalar+insert. It can help in IR because
it removes a shuffle, and the backend can already narrow
loads if that is profitable in codegen.

We might be able to consolidate more of the logic, but
handling this basic pattern should be enough to make a small
difference on one of the motivating examples from issue #17113.
The final goal of combining loads on those patterns is not
solved though.

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

[SystemZ] add test for mergeTruncStores miscompile; NFC

This is based on the example in issue #58883. I'm not sure
if the output currently shows the potential miscompile,
so we may want to adjust the test in a follow-up.

AArch64/GlobalISel: Regenerate some test checks to include -NEXT

[SLP]Redesign vectorization of the gather nodes.

Gather nodes are vectorized as simply vector of the scalars instead of
relying on the actual node. It leads to the fact that in some cases
we may miss incorrect transformation (non-matching set of scalars is
just ended as a gather node instead of possible vector/gather node).
Better to rely on the actual nodes, it allows to improve stability and
better detect missed cases.

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

[OpenCL] Fix diagnostics with templates in kernel args.

Improve checking for the standard layout type when diagnosing
the kernel argument with templated types. The check doesn't work
correctly for references or pointers due to the lazy template
instantiation.

Current fix only improves cases where nested types in the templates
do not depend on the template parameters.

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

[lldb] Make callback-based formatter matching available from the CLI.

This change adds a `--recognizer-function` (`-R`) to `type summary add`
and `type synth add` that allows users to specify that the names in
the command are not type names but python function names.

It also adds an example to lldb/examples, and a section in the data
formatters documentation on how to use recognizer functions.

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

add LoongArchTargetParser.def to LLVM_Utils module

Weinling Lu's change from https://reviews.llvm.org/D136146
fails to build with -DLLVM_ENABLE_MODULES=1 cmake builds
like the LLDB Incremental CI bot on greendragon; this entry
is sufficient to unblock that style of build, it seems.

[SLP][NFC]Add a test for vectorization with scheduling blocks order
different than the instruction order, NFC.

Add deduction guides for IRBuilder

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

AArch64/GlobalISel: Regenerate test checks

Add constant time mapping from enumeration to string in ENUM_CLASS
macro

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