[libc] Forward CUDA options to the runtimes invocation of `libc`

Some configurations may require `-DCUDAToolkit_ROOT` to find CUDA
properly. This is currently not forwarded to the CMake invocation. This
patch adds a prefix so it will be visible when the runtimes build is
started.

Reviewed By: tra

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

[libc] Ensure that the required clang tools are up-to-date for libc GPU

The `clang-offload-packager`. `nvptx-arch`, and `amdgpu-arch` tools are
required for building the GPU target of `libc`. This patch ensures that
we build this tool when directly building `libc` via `ninja libc` or similar.

Reviewed By: tra

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

[nvptx-arch] Dynamically load `libcuda.so.1` directly instead

This patch loads the CUDA driver library directly via its real
`DT_SONAME`. This prevents the filesystem from needing to reload it in
cases when it's already loaded.

Reviewed By: tra

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

[FS-AFDO] Assign discriminators to pseudo probes

This is the first change for FS-AFDO integration with CSSPGO. There are more patches coming.

With pseudo probes, we do not assign FS discriminators to any other instructions since we will be using only probes for profile correlation.

Also call instructions are excluded since their dwarf discriminators are used for other purposes, i.e, storing probe ids. Since they are not getting a FS discriminator, they will also be excluded from MIR profile loading. The corresponding changes will be in the subsequent patches.

Reviewed By: wenlei

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

[M68k] Add `TRAP`, `TRAPV`, `BKPT`, `ILLEGAL` instructions

This makes it possible to use TRAP to make Linux system calls using
inline assembly for instance.

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

asan_memory_profile: Fix for deadlock in memory profiler code.

Calling symbolization directly from stopTheWorld was causing deadlock.
For libc dep systems, symbolization uses dl_iterate_phdr, which acquire a
dl write lock. It could deadlock if the lock is already acquired by one of
suspended.

Reviewed By: vitalybuka

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

Simplify test.

This test doesn't actually depend on being able to launch the process.
This may or may not explain why this test behaves oddly on some of our bots.

Simplify test script

[clang][lit] Make LIT aware of env CLANG_CRASH_DIAGNOSTICS_DIR.

This is useful for retriving crash reports of LIT runs when the
temporary folder is not accessible.

Reviewed By: michaelplatings

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

[BPF] Fix assembly parsing errors for atomic_fetch_* instructions

Fixes BPF assembler parsing errors for the following instructions:
- atomic_fetch_add
- atomic_fetch_and
- atomic_fetch_xor
- atomic_fetch_or
- cmpxchg32_32
- cmpxchg_64
- xchg32_32
- xchg_64

Also add a test to verify that all instructions could be assembled and disassembled.

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

[SPIR-V] Remove switch G_ICMP+G_BRCOND+G_BR before ISel

IRTranslator lowers switches to [G_SUB] + G_ICMP + G_BRCOND + G_BR
sequences. Since values and destination MBBs are included in the
spv_switch intrinsics, the sequences are not needed for ISel.

Before this commit, the information decoded by these sequences were
added to spv_switch intrinsics in SPIRVPreLegalizer and the sequences
were kept until SPIRVModuleAnalysis where they were marked skipped for
emission.

After this commit, the [G_SUB] + G_ICMP + G_BRCOND + G_BR sequences
and MBBs containing only these MIs are erased in SPIRVPreLegalizer.

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

[MC][WebAssembly] Fix type checking for bulk memory instructions

This code currently assumes that all bulk memory operations occur on
memory 0 which who's type is determined by the wasm32 vs wasm64 target
triple.  Further improvements would be need to support multi-memory.

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

[msan] Fix handling of ParamTLS overflow.

Ironically, MSan copies uninitialized data off the stack into
VAArgTLSCopy in the callee-side handling of va_start. Clamp the copy
size to the actual length of the buffer, and zero-initialize the
remainder.

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

[-Wunsafe-buffer-usage] Fix-Its transforming `&DRE[any]` to `&DRE.data()[any]`

For an expression of the form `&DRE[any]` under an Unspecified
Pointer Context (UPC), we generate a fix-it for it with respect to a
strategy. In case the strategy is `std::span` (it is the only supported
one for now), the fix-it replaces the expression with
`&DRE.data()[any]`.

A UPC includes at least the contexts where
- the expression is being casted to an integer; and
- the expression is an argument of a call to a function that is not marked unsafe.

Reviewed by: NoQ, malavikasamak, t-rasmud, jkorous

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

[lldb] Fix build on older FreeBSD

Commit 392d9eb03af5a1adac66a86939351b22b3e73495 added a dependency on
FPE_FLTIDO which was only defined in FreeBSD main on May 19, 2022 and
is not in all supported releases. Just define it if it's missing as we
could use a debugger compiled on an older system to debug a newer one.

Reviewed by: DavidSpickett, emaste, dim

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

[LV] Add uses of recurrences in exit blocks in some tests.

This preserves the spirit of the tests even if a follow-up changes only
generates exit values for recurrences if they are actually used.

[AIX][PGO] Add malloc error handling and deallocation to FindBinaryId function

This is a follow up on D146976.

Reviewed By: stephenpeckham

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

[RISCV] Add tests for extract/insert subvector costs and extract lowering

[RISCV][TTI] Cost SK_Tranpose as a generic two element shuffle

This matches the actual lowering.  The previous costing was "as if" it had been fully scalarized.

[Verifier] Verify sizes of matrix.multiply operands and specified shape.

Extend the verifier to check if the size of the matrix operands of
matrix.multiply match the sizes specified by the numeric arguments.

Reviewed By: thegameg

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

[DebugInfo][flang] Fix linking modules with similar DIStringType

This issue is caused by incomplete implementation of isKeyOf for DIStringType.

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

[HWASAN] Fix test which was failing with tag mismatch due to missing no_sanitize statement

[flang] HLFIR to FIR lowering for complex parts

This revision implements HLFIR to FIR lowering for complex parts.

Reviewed By: jeanPerier

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

[mlir] Introduce IRDL dialect

This patch introduces the IRDL dialect, which allow users to represent
dynamic dialect definitions as an MLIR program.

The IRDL dialect defines operations, attributes, and types, using
attribute constraints. For example:

```
module {
  irdl.dialect @cmath {
    irdl.type @complex {
      %0 = irdl.is f32
      %1 = irdl.is f64
      %2 = irdl.any_of(%0, %1)
      irdl.parameters(%2)
    }

    irdl.operation @norm {
      %0 = irdl.any
      %1 = irdl.parametric @complex<%0>
      irdl.operands(%1)
      irdl.results(%0)
    }
}
```

This program will define a new `cmath.complex` type, which expects a single
parameter, which is either an `f32` or an `f64`. It also defines an
`cmath.norm` operation, which expects a single `cmath.complex` type as operand,
and returns a value of the underlying type. Note that like PDL (which IRDL is
heavily inspired from), both uses of `%0` are expected to be of the same attribute.

IRDL handles attributes and types with the same operations, and does this by always
wrapping types in a `TypeAttr`. This is to simplify the language.

Depends on D144690

Reviewed By: rriddle, mehdi_amini

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

[scudo] Make the placeholder type specifier be consistent with C/C++

This avoids `-Wformat` complains the placeholder type specifier mismatch
on `lld`/`llu`(used for `s64`/`u64`) which have slightly different
interpretation in string_utils.cpp.

Also enable Timer build which was disabled because of the complaining of
`-Wformat`.

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

[APFloat] Refactor common code for APFloat<->APInt conversion

All the IEEE formats are quite similar, we can merge their code
effectively by writing it parametrically via the fltSemantics object.

We can metaprogram the implementation such that this parametricity is
zero-cost.

[amdgpu] Implement dynamic LDS accesses from non-kernel functions

The premise here is to allow non-kernel functions to locate external LDS variables without using LDS or extra magic SGPRs to do so.

1/ First it crawls the callgraph to work out which external LDS variables are reachable from a given kernel
2/ Then it creates a new `extern char[0]` variable for each kernel, which will alias all the other extern LDS variables because that's the documented behaviour of these variables
3/ The address of that variable is written to a lookup table. The global variable is tagged with metadata to track what address it was allocated at by codegen
4/ The assembler builds the lookup table using the metadata
5/ Any non-kernel functions use the same magic intrinsic used by table lookups of non-dynamic LDS variables to find the address to use

Heavy overlap with the code paths taken for other lowering, in particular the same intrinsic is used to pass the dynamic scope information through the same sgpr as for table lookups of static LDS.

Reviewed By: arsenm

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

[MergedLoadStoreMotion] Merge stores with conflicting value types

Since memory does not have an intrinsic type, we do not need to require value type matching on stores in order to sink them. To facilitate that, this patch finds stores which are sinkable, but have conflicting types, and bitcasts the ValueOperand so they are easily sinkable into a PHINode. Rather than doing fancy analysis to optimally insert the bitcast, we always insert right before the relevant store in the diamond branch. The assumption is that later passes (e.g. GVN, SimplifyCFG) will clean up bitcasts as needed.

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

[lld][WebAssembly] Fix stub library parsing with windows line endings

Also, fix checking of first line in ::parse.  We can't use the
::getLines helper here since that already does comment stripping
internally.

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

[dsymutil] Disallow --reproducer=Use

This should be implied by --use-reproducer instead as a path is required
for this mode

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

Revert "AMDGPU: Created a subclass for the return address operand in the tail call return instruction"

This reverts commit 461a559bc9bd755436ba8f12f8b74757e03f9b9f.

Do not move "auto-init" instruction if they're volatile

This is overly conservative, but at least it's safe.

This is a follow-up to https://reviews.llvm.org/D137707

[lld] Support separate native object file path in --thinlto-prefix-replace

Currently, the --thinlto-prefix-replace="oldpath;newpath" option is used during
distributed ThinLTO thin links to specify the mapping of the input bitcode object
files' directory tree (oldpath) to the directory tree (newpath) used for both:

1) the output files of the thin link itself (the .thinlto.bc index files and the
optional .imports files)
2) the specified object file paths written to the response file given in the
--thinlto-index-only=${response} option, which is used by the final native
link and must match the paths of the native object files that will be
produced by ThinLTO backend compiles.
This patch expands the --thinlto-prefix-replace option to allow a separate directory
tree mapping to be specified for the object file paths written to the response file
(number 2 above). This is important to support builds and build systems where the
same output directory may not be written by multiple build actions (e.g. the thin link
and the ThinLTO backend compiles).

The new format is: --thinlto-prefix-replace="origpath;outpath[;objpath]"

This replaces the origpath directory tree of the thin link input files with
outpath when writing the thin link index and imports outputs (number 1
above). If objpath is specified it replaces origpath of the input files with
objpath when writing the response file (number 2 above), otherwise it
falls back to the old behavior of using outpath for this as well.

Reviewed By: tejohnson, MaskRay

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

[AArch64][GlobalISel][RegBankSelect] Guess the bank for loads using the MMO.

We had this patch downstream for a long time, we need to find the users of the
IR load to guess the bank since with opaque pointers we lost the type information.

[fuzzer][test] Avoid big-file-copy.test on memory constrained devices

The test "big-file-copy.test" introduced in D146189 and constrained to darwin by
D147094, is by this differential further constrained to only those devices with
sufficient resources. Also correct the test to read the environment variable
"result" from the same shell in which it was stored (which may differ on devices).

Reviewed By: thetruestblue

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

AMDGPU: Created a subclass for the return address operand in the tail call return instruction

Summary:
  This is to avoid using the callee saved registers for the return address of the tail call return instruction.

Reviewers:
  arsenm, cdevadas

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

Bazel: Try alwayslink

Bazel: Try textual hdrs for tblgen .def file

Bazel fix spelling

Bazel add missing comma

Bazel fix - try splitting out llvm-tblgen into a library to support .def files

Revert "[compiler-rt] Fix scudo build on ARM"

This broke fuchsia cross-compile.

This reverts commit f1f3dd64bfd2af94f9cccd01cf9e213fe3e69707.

[IR] Rename a couple calls to ConstantInt::getNullValue to Constant::getNullValue. NFC

There is no getNullValue in ConstantInt. Due to inheritance, it's
really Constant::getNullValue.

Most of the calls in tree that use ConstantInt::getNullValue do
know the type is an integer. These two calls allow pointers so
shouldn't use "ConstantInt".

Bazel build fix, second try

Bazel build fix for X86ManualFoldTables.def

[ExtractAPI] Remove extra attributes in property declaration fragments

Use `getPropertyAttributesAsWritten` instead of `getPropertyAttributes`
to get property attributes actually specified in the source code.
Resolves issue #61478.

https://reviews.llvm.org/D146759

Reviewed By: zixuw, dang

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

[ARM] Add some tests for MVE vcmla combines. NFC

See D147200 and D147201

[IR] Remove ConstantFP::getZeroValueForNegation.

This was mostly used for integers which was fixed in D147492.

The only FP usage was removed in D147497.

Reviewed By: nikic

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

[CodeGen] Add machine verification to a couple of tests

This helps to provoke a couple of errors when I apply D129208 that would
otherwise only show up in an LLVM_ENABLE_EXPENSIVE_CHECKS build.

Revert "Recommit DwarfEHPrepare: insert extra unwind paths for stack protector to instrument"

This broke Objective-C autorelease / retainAutoreleasedReturnValue, see
comments on the code review.

> This is a mitigation patch for
> https://bugs.chromium.org/p/llvm/issues/detail?id=30, where existing stack
> protection is skipped if a function is returned through by an unwinder rather
> than the normal call/return path. The recent patch D139254 added the ability to
> instrument a visible unwind path, at least in the IR case (I'm working on the
> SelectionDAG instrumentation too) but there are still invisible unwinds it
> can't reach.
>
> So this patch adds logic to DwarfEHPrepare that goes through a function,
> converting any call that might throw into an invoke to a simple resume cleanup,
> and adding cleanup clauses to existing landingpads that lack them. Obviously we
> don't really want to do this if it's wasted effort, so I also exposed
> requiresStackProtector from the actual StackProtector code to skip the extra
> paths if they won't be used.
>
> Changes:
>   * Move test to AArch64 directory as it relies on target presence.
>   * Re-add Dominator-tree maintenance. Accidentally cherry-picked wrong patch.
>   * Skip adding paths on Windows EH functions.
>
> https://reviews.llvm.org/D143637

This reverts commit 2d690684f66fabc9ac6a2c70fcff3b31c9520794.

[Flang] Change fir.divc to perform library call rather than generate inline operations.

Currently `fir.divc` is always lowered to a sequence of llvm operations to perform complex division, however this causes issues for extreme values when the calculations overflow. While this behaviour would be fine at -Ofast, this is currently the default at all levels.

This patch changes `fir.divc` to lower to a library call instead, except for when KIND=3 as there is no appropriate library call for this case.

Reviewed By: vzakhari

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

[AArch64] Use fneg instead of fsub -0.0, X Cin IR expansion of __builtin_neon_vfmsh_f16.

Addresses the FIXME and removes the only in tree use of
llvm::ConstantFP::getZeroValueForNegation for an FP type.

Reviewed By: dmgreen, SjoerdMeijer

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

[IR] Remove uses of the oddly named ConstantFP::getZeroValueForNegation in integer code.

Confusingly ConstantFP's getZeroValueForNegation intentionally
handles non-FP constants. It calls getNullValue in Constant.

Nearly all uses in tree are for integers rather than FP. Maybe due
to replacing FSub -0.0, X idiom with an FNeg instructions a few
years ago.

This patch replaces all the integer uses in tree with ConstantInt::get(0, Ty).

The one remaining use is in clang with a FIXME that it should use fneg.
I'll fix that next and then delete ConstantFP::getZeroValueForNegation.

Reviewed By: nikic

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

[OpenMP][libomptarget] Do not rely on AsyncInfoWrapperTy's destructor

[RISCV] Add FIXME comment about expensive vector mem op costs

[ARM] Fix VMOVSR pattern requirements

The required target features for VMOVSR instruction (integer -> MVE
FP register copy) are HasFPRegs and UseVMOVSR (see
https://reviews.llvm.org/D60694).

The instruction selection pattern must use the same set of
requirements (i.e., HasFPRegs instead of HasVFP2). The discrepancy
can cause instruction selection failure when compiling code for
execute-only position-independence mode.

Reviewed By: dmgreen

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

[flang] Correctly lower optional assumed type dummy

Assumed type are represented differently in the ActualArgument
class. Correctly handle them in intrinsic arg lowering.

Reviewed By: PeteSteinfeld

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

[X86] Prefer `vpternlog` instead of `blendv` for `vselect` on masks.

This rarely comes up because most `vselect` are lowered with actually
avx512 mask instructions, but is an improvement in the rare cases.

Reviewed By: RKSimon

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

Recommit "[X86] Simplify some `pternlog` intrinsics" (2nd Try)

Original location of the unittests was Transforms/InstCombine/X86
which caused an issue as non-x86 targets ended up with a dependency on
X86 which isn't right.

Moved the unit tests to Target/X86 so should be good now.

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

[WebAssembly] Add libcall signatures for roundeven

Since clang started emitting roundeven intrinsics in a7d6593a0a17, they would
cause a crash in the WebAssembly backend because it did not know the roundeven
library function signatures. Fix the crash by adding the signatures.

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

[clang][modules] Handle explicit modules when checking for .Private -> _Private

While we eventually want to remove the mapping from .Private to _Private
modules, until we do, ensure that it behaves the same for explicit
modules.

rdar://107449872

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

[bazel] -lrt is not available on Android.

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

[flang] Fix -Wsign-compare in check-call.cpp (NFC)

/data/llvm-project/flang/lib/Semantics/check-call.cpp:1234:29: error: comparison of integers of different signs: 'int' and 'size_type' (aka 'unsigned long') [-Werror,-Wsign-compare]
  CHECK(index >= 0 && index < actuals.size());
                      ~~~~~ ^ ~~~~~~~~~~~~~~
/data/llvm-project/flang/include/flang/Common/idioms.h:89:20: note: expanded from macro 'CHECK'
                   ^
1 error generated.

[clang-format] Add option for having one port per line in Verilog

We added the option `VerilogBreakBetweenInstancePorts` to put ports on
separate lines in module instantiations.  We made it default to true
because style guides mostly recommend it that way for example:

https://github.com/lowRISC/style-guides/blob/master/VerilogCodingStyle.md#module-instantiation

Reviewed By: HazardyKnusperkeks

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

[X86] combineBitcastvxi1 - peek through bitcast(concat(X,undef,undef,undef)) -> aext(bitcast(X))

Improves fix for #61683 to handle cases where the legalization concatenation isn't just 2 subops.

[MachineVerifier] Try harder to verify SlotIndexes

Verify the SlotIndexes analysis after a pass that claims to preserve it,
even if there are no further passes (apart from the verifier itself)
that would use the analysis.

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

[RISCV] Model vlseg/vsseg in interleaved memory ops

If the legalized type is a legal interleaved access type (i.e. there's a
supported vlseg/vsseg instruction for it), the interleaved access pass
will pick any interleaved memory op (wide load + shuffles) and lower it
into a vlseg/vsseg intrinsic.

Reviewed By: reames

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

[NFC][LoopVectorize] Simplify preferPredicateOverEpilogue interface

Given just how many arguments we pass to
preferPredicateOverEpilogue and considering this list may
grow over time I've decided to pass in a pointer to a new
TailFoldingInfo structure instead, similar to what we do
with IntrinsicCostAttributes, etc. In addition, many of the
arguments we pass in are actually available in the
LoopVectorizationLegality class so I've managed to
reduce the set of pointers that we need to pass in the
TailFoldingInfo struct.

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

Revert "[mlir][arith] Add expansion pattern for ext/trunc of bf16"

This reverts commit 5bff523793ee8c30c260cc77b23c61dcbb606486. The
bf16->f32 conversion is incorrect. This can't be on by default, if you
want this behavior make it a separate pass.

[X86] LowerVectorAllEqual - generalize mask type generation. NFC.

This will be necessary once we merge with combineVectorSizedSetCCEquality and we need to support KORTEST handling for 128/256-bit comparisons

[Flang][PowerPC] Implement PPC mtfsf/mtfsfi intrinsics

Implements the PowerPC mtfsf and mtfsfi intrinsics as well as introduces semantic error checking code for PowerPC intrinsics

Reviewed By: klausler

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

[X86] Add additional test coverage for Issue #61683

Show failure for other vector size concatenations

[lld-macho] Check if DWARF offset is too large for compact unwind

For functions that use DWARF encodings, their compact unwind entry will
contain a hint about the offset of their DWARF entry from the start of
the `__eh_frame` section. The encoding only has 3 bytes to encode this
hint.

Previously, I neglected to check for overflow (and didn't realize that
the value was merely a hint without needing to be exact.) So for large
`__eh_frame` sections, the hint would overflow and cause the compact
unwind MODE flag to be corrupted, leading to uncaught exceptions at
runtime.

This diff fixes things by encoding zero as the hint for offsets that are
too large. The unwinder will start a linear search at the hint location
for the matching CFI record. The only requirement is that the hint
points to a valid CFI record start, and the start of the section is
always the start of a CFI record (in well-formed programs).

I'm not adding a test for this because generating the test inputs takes
a bit too much time. However, I have been testing locally with this lit
file, which takes about 15s to run on my machine:

```
# RUN: rm -rf %t; mkdir %t
# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-macos11.0 %s -o %t/test.o
# RUN: %lld -dylib -lSystem %t/test.o -o %t/test

.subsections_via_symbols
.text
.p2align 2

_f:
  .cfi_startproc
.rept 0x7fffff
  .cfi_escape 0x2e, 0x10
.endr
  ret
  .cfi_endproc

_g:
  .cfi_startproc
  .cfi_escape 0x2e, 0x10
  ret
  .cfi_endproc
```

Reviewed By: #lld-macho, smeenai

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

[X86] Remove unused variable

Leftover from eb435b7ff569b35ae603886b881f51ac8600bd60

[Headers] Add some intrinsic function descriptions to immintrin.h.

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

[X86] combineBitcastvxi1 - peek through bitcast(concat(X,undef)) -> aext(bitcast(X))

Fixes #61683

[python] Expose clang_Location_isInSystemHeader

Add is_in_system_header property for Location class.

Corresponding unit test was also added.

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

[X86] Add test coverage for Issue #61683

Drop U6Imm-related definitions

They are no longer used, which leads to the -Wunused-function warning.

Reviewed By: uweigand

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

[RISCV] Move shuffle-reverse test to rvv directory. NFC

Test is related to vectors so probably belongs in the rvv directory

Reviewed By: craig.topper

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

Revert "[test] Remove occurences of br undef in CodeGen/AMDGPU tests"

This reverts commit 18c594c176036b7ffcd8439ed9c4b08d2085a244.
Build bots broke

[X86][mem-fold] Refine code, NFCI

1. Remove redundant definition of constructor
2. Move the array in .inc to .def file
3. Add a licence for the .def file

MachO use generic code to detect atomic support.

The default code can detect what width of atomic instructions are supported
based on the targeted architecture profile, version etc so there's no need to
hard-code 64 on Darwin targets (especially as it's wrong in most M-class
cases).

[SystemZ] Remove unused function 'decodeU6ImmOperand' in SystemZDisassembler.cpp (NFC)

/data/llvm-project/llvm/lib/Target/SystemZ/Disassembler/SystemZDisassembler.cpp:209:21: error: unused function 'decodeU6ImmOperand' [-Werror,-Wunused-function]
static DecodeStatus decodeU6ImmOperand(MCInst &Inst, uint64_t Imm,
                    ^
1 error generated.

[test] Remove occurences of br undef in CodeGen/AMDGPU tests

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

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

[compiler-rt] Fix scudo build on ARM

The build of scudo was failing on armv7l, with undefined references
to unwinder symbols, such as __aeabi_unwind_cpp_pr0. These are
needed by RTGwpAsan and thus, on ARM, scudo must also be linked
against an unwind library.

The cmake command that caused the build failure was:

cmake --fresh -S "$PWD/llvm/" -B "$PWD/build/" -G Ninja \
  -DCMAKE_INSTALL_PREFIX="$PWD/install" \
  -DCMAKE_BUILD_TYPE=Release \
  -DLLVM_ENABLE_PROJECTS="clang;lld;lldb;clang-tools-extra;polly" \
  -DLLVM_ENABLE_RUNTIMES="compiler-rt;libcxx;libcxxabi;libunwind" \
  -DLLVM_TOOLCHAIN_TOOLS="llvm-ar;llvm-ranlib;llvm-objdump;\
llvm-rc;llvm-cvtres;llvm-nm;llvm-strings;llvm-readobj;\
llvm-dlltool;llvm-pdbutil;llvm-objcopy;llvm-strip;llvm-cov;\
llvm-profdata;llvm-addr2line;llvm-symbolizer;llvm-windres;llvm-ml;\
llvm-readelf;llvm-size" \
  -DLLVM_INSTALL_BINUTILS_SYMLINKS=OFF -DLLVM_PARALLEL_LINK_JOBS=1

Fixes #60115

Reviewed By: hctim

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

[DebugInfo] don't make an MDTuple just to leak it

There does not seem to be any purpose to allocating this object, which
is Metadata, so LLVM will simply leak it until the context is destroyed
(the subprogram metadata it contains are distinct, so there is little
chance of it being reused later). This should not have a functional
change.

This seems to be left over from an earlier design, when it used to call
```
CUNode->replaceSubprograms(SPs.get());
```
here also. (removed in http://reviews.llvm.org/D19034)

Reviewed By: aprantl

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

[SystemZ] Allow any I5 in RotateSelect*

For all RotateSelect* instructions, PoP says:

    Bits 0-1 of the I5 field (bits 32-33 of the instruction) are
    ignored.

LLVM, however, completely prohibits using them, e.g.:

    error: invalid operand for instruction
    asm("rxsbg %[r1],%[r2],177,43,228\n"

Lift this unnecessary restriction.

Reviewed By: uweigand

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

[X86] Convert test to opaque pointers (NFC)

Retaining bitcasts to keep test intent.

addrsig_sym is no longer emitted for metedata_f1, but this
improvement is ultimately inconsequential, as it will get dropped
at a later stage anyway.

[lit] Implement -I option for builtin "diff" command to ignore changes where all lines match RE

Reviewed By: pengfei

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

[Verifier] Rename matrix-intrinsics-opaque-ptrs.ll->matrix-intrinsics.ll

The original typed pointer version of the tests (matrix-intrinsics.ll)
is now obsolete. Replace matrix-intrinsics.ll with
matrix-intrinsics-opaque-ptrs.ll.

[X86][NFC] Remove redundant flags used in x86-auto-memfold.td

[include-cleaner] Only ignore builtins without a header

Certain standard library functions (e.g. std::move) are also implemented
as builtins. This patch moves filtering logic to the symbol->header
mapping phase to rather generate these references without any providers
only when we don't have a mapping.
That way we can also map them to header names mentioned in the builtin
mappings.

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

[X86] Convert test to opaque pointers (NFC)

[X86] Regenerate test checks (NFC)

[NFC][AArch64] Late 2022 A-Profile Extension Release Notes

[Thumb2] Convert tests to opaque pointers (NFC)

[Thumb2] Name instructions in tests (NFC)

[CodeGen] ExpandReductions - add reduce_and/or(<X x i1> V) -> icmp(iX bitcast(<X x i1> V)) canonicalization

This already exists in InstCombine but was missing from the late stage ExpandReductions pass

Fixes #53419
Fixes #61923

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