[MSAN] Replace another open-coded convertToBool instance [nfc]

Note that getCleanShadow always returns Constant::getNullValue so the prior code is equivalent to convertToBool.

[MSAN] Inline getShadowTyNoVec into convertShadowToScalar [nfc]

This is an implementation detail of the flattening scheme, so hide it in the implementation thereof.  This does require one caller to go through the appropriate utility, but doing that makes the code cleaner anyways.

[X86] Add more thorough testing of the zext(logicalshift(zext(x),c)) -> logicalshift(zext(x),c) fold

Add tests for more extension combos, 64-bit targets and some illegal types

[NFC][libc++] Uses newer libc++ style.

[InlineOrder] Plugin Inline Order

Adds the ability to load a plugin to control the inline order.
This allows developing and distributing inlining heuristics
outside of tree. And together with the inline advisor plugins
allows for fine grained control of the inliner.

The PluginInlineOrderAnalysis class serves as the entry point
for dynamic advisors. Plugins must register instances of this
class to provide their own InlineOrder.

Reviewed By: kazu

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

Revert "[InlineOrder] Plugin Inline Order"

This commit is causing a CMake error on AIX. Will recommit with
a fix.

This reverts commit e46d8a731535afcf0c5c2a2f6cf3c5d4fb69cd5b.

[Dexter] Add target_run_args option

Adds an option to Dexter that passes command line arguments to the
debugged process, following (and in addition to) any arguments given by
the DexCommandLine command.

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

[codegen][riscv] Emit CFI directives when using shadow call stack

Currently we don't emit any CFI instructions for the SCS register when
enabling SCS on RISCV. This causes problems when unwinding, since the
SCS register isn't being handled properly.

Reviewed By: mcgrathr

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

[clang][RISCV][NFC] Combine RV32/RV64 ABI tests into single files

After D134050, it makes sense to combine the RV64 ABI tests into a
single file in order to make it more maintainable (i.e. not having to
split tests based on the combinations of ABIs they're expected to
impact). This patch deletes duplicated tests but doesn't do much further
reorganisation beyond that.

I imagine the logical ordering of tests in the file and comments could
be further improved in the future. My personal feeling is that it's
probably not worth investing the time to try to get this "perfect", and
to instead settle for this incremental step forward. But if there's
reviewer interest in attempting to further iterate, I'm happy to do so.

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

[NFC][libc++] Fixes a typo.

[libc++][charconv] Granularizes the header.

Having the header granularized makes it possible to remove the
dependency on this header in <format>. This <format> header gets
included in more headers due to more usage of std::formatter in the
library. This should reduce the number of transitive includes.

Note formatting the new headers will be done in a followup patch.

Reviewed By: #libc, ldionne

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

[libc++] Disables transitive includes in library.

I noticed this wile investigating https://llvm.org/PR61314

Reviewed By: #libc, ldionne

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

[flang] Detect fir.class nested in fir.box as invalid element type

Catch invalid element type in fir.box in the verifier so
it does not propagate later in lowering.

Reviewed By: PeteSteinfeld

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

[RISCV][TTI] Fix indentation and remove tabs [nfc]

[flang] Avoid to wrap box/class type with box/class

Adapat the fix made in D146079 to just avoid the type
to be wrapped with an extra fir.box or fir.class. The potential
load is delegated to the code that is after.

Reviewed By: PeteSteinfeld

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

[Debugify] Invalidate function analyses

Since debugify inserts instructions.

[mlir][Affine] Use stable sorting to prevent non-determinism

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

[ADT] Make llvm::is_contained call member `contains` or `find` when available

This makes it so that calling `llvm::is_contained` no longer degrades
performance over member contains, even though both have almost identical
names. This would be the case in most set/map classes that can check for
an element being present in O(1) or O(log n) time vs. linear scan with
`std::find`. For C++17 maps/sets without `.contains`, use `.find` when available,
falling back to a linear scan with `std::find`.

I also considered detecting member contains and triggering a
`static_assert` instead, but decided against it because it's just as easy
to do the right thing and call `.contains`. This would also make some code fail
only when compiled in the C++20 mode when more container types come with
`.contains` member functions.

This was actually already the case with `CommandLine.h` calling `is_contained`
on `SmallPtrSet` and in a recent BOLT patch.

Reviewed By: kazu, dblaikie, MaskRay

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

[compiler-rt] Point UndefinedBehaviorSanitizer link to its own page.

[InstCombine] Add additional test for icmp eq/ne with bool load (NFC)

[ASAN] Use AI.getAllocationSize() helper (NFC)

Use *{Map,Set}::contains (NFC)

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

[clang][RISCV][NFC][test] Move riscv-abi.cpp and riscv{32,64}-*abi.c tests to use update_cc_test_checks.py

This patch implements an initial step towards refactoring our ABI tests
(moving them to update_cc_test_checks.py). Future patches combine them.

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

[InstCombine] Regenerate test checks (NFC)

[StandardInstrumentations] Only turn on -verify-cfg-preserved by default in expensive checks builds

https://llvm-compile-time-tracker.com/compare.php?from=3fd42f50d8aadb4d0c348ac17cd2115c1b0564a4&to=50c37f6fc62a1e7bb4f0e307c89f760d42dbe4e9&stat=instructions:u
shows that this is fairly expensive, 5-10% increase in compile time, and I'd like to add more similar checks under the same flag.

This matches the legacy pass manager.

Reviewed By: nikic

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

[gn build] Manually port fe7b38

[PassManager] Run PassInstrumentation after analysis invalidation

This allows instrumentation to inspect cached analyses to verify them.

The CGSCC PassInstrumentation previously ran `runAfterPass()` on the original SCC, but really it should be running on UpdatedC when relevant since that's the relevant SCC after the pass.

Reviewed By: nikic

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

[flang] Rebox the polymorphic argument in merge intrinsic

When fsource or tsource is not polymorphic, the result is not
polymorphic. Rebox the polymoprhic arguement so the dynamic
type of the result is correct.

Reviewed By: PeteSteinfeld

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

[DWARFLinker][DWARFv5] add support for DW_FORM_implicit_const form.

This patch adds handling of DW_FORM_implicit_const form.

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

[AMDGPU] Update mul.ll with auto-generated checks

Reviewed By: foad

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

[X86] add-and-not.ll - add 32-bit test coverage

[ASAN] Initial support memory checks on scalable vector typed allocas

This patch adjusts the memory instrumentation to account for scalable vector types in allocas. Note that we don't allow scalable vector globals, so we don't need to update that codepath.

A couple points.

First, this simply disables the optimization for scalable allocas. We can revisit this in the future, but it requires a bit of plumbing to get scalable object sizes through the visitor to be useful.

Second, I am simply disabling stack poisoning for scalable vector allocas. This is mostly for staging the change as I can't write a working test for memory instrumentation without doing so. I don't think it's unreasonable to do on it's own basis as without the bailout, we crash the compiler.

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

[ADT][mlir][NFCI] Do not use non-const lvalue-refs with enumerate

Replace references to enumerate results with either result_pairs
(reference wrapper type) or structured bindings. I did not use
structured bindings everywhere as it wasn't clear to me it would
improve readability.

This is in preparation to the switch to zip semantics which won't
support non-const lvalue reference to elements:
https://reviews.llvm.org/D144503.

I chose to use values instead of const lvalue-refs because MLIR is
biased towards avoiding `const` local variables. This won't degrade
performance because currently `result_pair` is cheap to copy (size_t
+ iterator), and in the future, the enumerator iterator dereference
will return temporaries anyway.

Reviewed By: dblaikie

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

[libc++][spaceship] Implement `operator<=>` for `map` and `multimap`

Implements parts of P1614R2: `operator<=>` for `map` and `multimap`

Reviewed By: #libc, philnik

Spies: philnik, libcxx-commits, yaxunl

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

[AMDGPU] Avoid constant bus limitation on V_BFE GISel pattern

For D141247 - if that pattern was used by GISel it could cause constant bus limitation failures.
Just use inline immediates instead of S_MOV to avoid the issue.

Reviewed By: arsenm

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

[AArch64][SVE] Fix the indexed addressing mode when FI = 0.

This is an alternative fix to D145497, which also addresses
  https://github.com/llvm/llvm-project/issues/60918

In D124457 which added the original code for this, @efriedma pointed
out that it wasn't safe to assume that FI #0 would be allocated at offset
0, but that part of the patch went in without any changes.

The downside of this solution is that any access to an object on the
stack that has been allocated at SP + 0, still gets moved to a separate
register first, which degrades performance.

Reviewed By: paulwalker-arm

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

[llvm-debuginfo-analyzer] README

llvm-debuginfo-analyzer is a command line tool that processes debug
info contained in a binary file and produces a debug information
format agnostic “Logical View”, which is a high-level semantic
representation of the debug info, independent of the low-level
format.

https://discourse.llvm.org/t/llvm-dev-rfc-llvm-dva-debug-information-visual-analyzer/62570

This patch:

Contains notes collected during the development, review and test.
It describes limitations, know issues and future work.

Reviewed By: Orlando

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

[DAG] TargetLowering::ShrinkDemandedOp - rename Demanded arg to DemandedBits. NFC

Make it clear this is referring to DemandedBits not DemandedElts.

[libclang] Add index option to store preambles in memory

This commit allows libclang API users to opt into storing PCH in memory
instead of temporary files. The option can be set only during CXIndex
construction to avoid multithreading issues and confusion or bugs if
some preambles are stored in temporary files and others - in memory.

The added API works as expected in KDevelop:
https://invent.kde.org/kdevelop/kdevelop/-/merge_requests/283

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

[mlir][Transforms] OperationFolder: Remove redundant `create` API

These functions are available on the `OpBuilder` API.

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

[mlir][Transform] NFC - Refactor forall mapping to threads and blocks into one thing

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

[DAG] mergeStore - peek through truncates when finding dead store(trunc(load())) patterns

Extend the existing store(load()) removal code to account for intermediate truncates that some targets won't remove with canCombineTruncStore - we only care about the load/store MemoryVT.

Fixes regression from D146121

[Clang] Give warning for an underaligned 128-bit __sync library call.

On SystemZ, int128 values are generally aligned to only 8 bytes per the ABI
while 128 bit atomic ISA instructions exist with a full 16 byte alignment
requirement.

__sync builtins are emitted as atomicrmw instructions which always require
the natural alignment (16 bytes in this case), and they always get it
regardless of the alignment of the value being addressed.

This patch improves this situation by giving a warning if the alignment is
not known to be sufficient. This check is done in CodeGen instead of in Sema
as this is currently the only place where the alignment can be computed. This
could/should be moved into Sema in case the alignment computation could be
made there eventually.

Reviewed By: efriedma, jyknight, uweigand

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

[Flang][RISCV] Emit target features for RISC-V

Fix the issue of .o file generated by `Flang`
with `Flags` info is 0x0 under RISC-V.

Reviewed By: awarzynski, kiranchandramohan

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

lit: Fix formatting in README.rst

This was preventing lit from being uploaded to pypi.

Reviewed By: mgorny

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

InstCombine: Handle folding fcmp of 0 into llvm.is.fpclass

This needs to consider the denormal mode.

Reapply "InstCombine: Fold is.fpclass(x, fcZero) to fcmp oeq 0"

This reverts commit 458ad6900e6635e4640229d40e6f713147e52de7.

[AArch64] Assembly Support for FEAT_GCS/FEAT_CHK

This implements support for two new 2022 A-profile extensions:
- FEAT_CHK - Check Feature Status Extension
- FEAT_GCS - Guarded Control Stacks

FEAT_CHK is mandatory from armv8.0-a, but is in the hint space so
there's no clang command-line flag for it, and we only print the hint as
`chkfeat x16` at v8.9a and above, to be compatible when using a
non-integrated assembler that might not yet know about the extension.

FEAT_GCS is optional from armv9.4-a onwards. It is enabled using `+gcs`
in a clang `-march=` or `-mcpu=` option string, or using a
`.arch_extension gcs` assembly directive.

This patch includes changes by Ties Stuij, Tomas Matheson, and Keith
Walker.

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

[DWARFLinker][DWARFv5] Support debug_loclists.

This patch adds support of DWARFv5 .debug_loclists table.
As DWARFLinker resolves relocations, it is able to always
use DW_FORM_addr instead of DW_FORM_addrx. DW_FORM_addrx
helps to minimize number of relocations, it is also used for
split DWARF. Both of these cases are not relevant for the
DWARFLinker. Thus, this patch converts all DW_FORM_addrx
forms into the DW_FORM_addr. And, as the result, it converts
location lists of DW_FORM_loclistx form into the DW_FORM_sec_offset.
For the --update case all DW_FORM_addrx, DW_FORM_loclistx
are preserved as is.

Depends On D145499

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

[clangd] Respect WantDiags when emitting diags from possibly stale preambles

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

Reland "[lldb] Refactor CrashReason"

This reverts commit 71c4d186f1cf247f1aa45f4fd1b38f350b68d123.
The reinterpret casts were not needed.

[OpenMP][libomptarget][AMDGPU] Update print launch info

Clean up for the AMD-specific kernel launch info in the NextGen Plugins.
- Fixes a mistake introduced with the initial commit that added printing
  of an AMD-only property.
- Removes another AMD-only property (not clear on upstream status)
- Adds some more comment to what info is printed.

Reviewed By: jdoerfert

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

[DAG] Fold multiple insert_vector_elt of zero values into an AND mask

This also allows us to make use of the existing isVectorClearMaskLegal shuffle canonicalization

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

Revert "[lldb] Refactor CrashReason"

This reverts commit af38530ee29c285f3827e33a41edf27c9c3a6767 due
to a build failure on 32 bit.

[lldb] Refactor CrashReason

So that there is only one function that NativeThreads call,
which takes a siginfo. Everything else is an internal detail.

Reviewed By: labath, JDevlieghere

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

Revert "[flang] Load fir.ref<fir.class<T>> instead of creating a wrong box"

This reverts commit fbca61c46612a6377b7d7cf5b56573df3c6759e2.

This is causing some issue. Revert for now.

[libunwind][RISC-V] Rewrite testcase with C as possible.

Fix #60472

The testcase is writen in all inline asm but it seems not well
maintained for the CFI directive, of cause we can fix that, but this
patch also contain another issue is it use s0 and s1 without
store/restore.

This patch proposed another way to testing that, use inline asm to
generate dummy def and use, so compiler will generate store/restore for
the vector register, and then generate the CFI directives.

Also check __riscv_vector as the testcase guard, because the testcase
will read vlenb which is only available when V or zve* extensions is
present.

Reviewed By: MaskRay, asb, #libunwind

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

[RISCV] Pass vector argument by stack correctly.

We've a argument lowering logic to prevent floating-point value pass
passed with bit-conversion, but that rule should not applied to vector
arguments.

---

How to pass argument to `foo`:

```
tail call void @foo(i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0,
                    <vscale x 16 x float> zeroinitializer,
                    <vscale x 16 x float> zeroinitializer,
                    <vscale x 16 x float> zeroinitializer)
```

`foo` take 13 arguments, first 8 argument pass in GPR, and next 2 LMUL 8 vector
arguments passed in v8-v23, and now we run out of argument register for GPR and
vector register, so we must pass last LMUL 8 vector argument by stack.

Which means we should reserve `vlenb * 8` byte for stack for the last
vector argument.

Reviewed By: craig.topper, asb

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

[RISCV] Precommit test to show wrong way to pass scalable FP vector on stack

Test case to demo scaleable vector on stack will cause stack corruption.

Detail explan what happened:

```
tail call void @foo(i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0, i32 0,
                    <vscale x 16 x float> zeroinitializer,
                    <vscale x 16 x float> zeroinitializer,
                    <vscale x 16 x float> zeroinitializer)
```

`foo` take 13 arguments, first 8 argument pass in GPR, and next 2 LMUL 8 vector
arguments passed in v8-v23, and now we run out of argument register for GPR and
vector register, so we must pass last LMUL 8 vector argument by stack.

However LLVM only reserve 8 byte on stack for the LMUL 8 vector
argument, it will cause stack corruption when we try to store that into
stack.

Reviewed By: craig.topper

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

[FuncSpec] Minor refactoring in statistics and debug messages.

* Remove redundant variable `NbFunctionsSpecialized` as it is no longer
  used by the cost model.
* Rename statistic `NumFuncSpecialized` to `NumSpecsCreated` as a better
  description (the old name confusingly implied number of functions we have
  created clones for).
* Same for variable `SpecializedFuncs`. Renamed to `Specializations`.
* Move debug message in the destructor (avoids repetition when MaxIters > 1).

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

[InstCombine] Remove one-use limit when it can simplify to a const in the pattern foldICmpUsingBoolRange

This patch follow up dd31a3b3a5, when the pattern return a constant we needn't limit it to one-use.

[InstCombine] Precommit tests for one-use check in icmp-range; NFC

[clang] Add AVR specific inline assembly escaped characters

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

Reviewed By: jacquesguan

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

[NVPTX] Expose LDU builtins

Also check if native half types are supported to give more descriptive
error message, without it clang only reports incorrect intrinsic return
type.

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

[AMDGPU] Use UniformityAnalysis in AtomicOptimizer

Adds & uses a new `isDivergentUse` API in UA.
UniformityAnalysis now requires CycleInfo as well as the new temporal divergence API can query it.

-----

Original patch that adds `isDivergentUse` by @sameerds

The user of a temporally divergent value is marked as divergent in the
uniformity analysis. But the same user may also have been marked divergent for
other reasons, thus losing this information about temporal divergence. But some
clients need to specificly check for temporal divergence. This change restores
such an API, that already existed in DivergenceAnalysis.

Reviewed By: sameerds, foad

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

[AMDGPU] Select v_sat_pk_u8_i16

The backend knew about `v_sat_pk_u8_i16` but never made use of it.
This patch adds selection patterns (DAG/GISel) for that instruction.
I think it'll be very rarely used, but at least it's possible to use it.

Solves #58266 (https://github.com/llvm/llvm-project/issues/58266)

Reviewed By: foad

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

[mlir][affine][analysis][NFC] Simplify FlatAffineConstraints API

* Remove `reset` function. Use copy assignment directly (instead of within `reset`).
* Fix potential `nullptr` dereference in `getFlattenedAffineExprs`.
* Make constraint set optional in `checkMemrefAccessDependence`.

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

[clangd] Patch main file macros in preamble

Depends on D146026
Fixes https://github.com/clangd/clangd/issues/1537.

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

[clangd] Patch PragmaMarks in preamble section of the file

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

[NFC] Add some debug printouts to CaptureTracking

[RISCV] Reserve X18 by default for Android

Reserve X18 even when -fsanitize=shadow-call-stack is not enabled.

Based on: https://reviews.llvm.org/D143355

Reviewed by: asb, samitolvanen, phosek, MaskRay

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

[Clang] Check feature requirement from inlined callee

Currently clang emits error when both always_inline and target
attributes are on callee, but caller doesn't have some feature.

This patch makes clang emit error when caller cannot meet target feature
requirements from an always-inlined callee.

Reviewed By: erichkeane

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

[polly] Use DenseMap::contains (NFC)

clang: Fix header tests for nofpclass

[flang] Use Use *{Set,Map}::contains (NFC)

clang: Handle MatrixType in hasFloatingRepresentation

Allows applying nofpclass to matrix arguments.

clang: Emit nofpclass(nan inf) for -ffinite-math-only

Set this on any source level floating-point type argument,
return value, call return or outgoing parameter which is lowered
to a valid IR type for the attribute. Currently this isn't
applied to emitted intrinsics since those don't go through
ABI code.

Attributor: Add baseline tests for nofpclass

clang: Add baseline test for nofpclass emission

CodeGen: Add some additional is_fpclass lowering tests

Cover more cases in preparation for making greater use
of fcmp based lowerings. Also add more tests for the inverted
cases. Test iszero | isnan test masks. We should probably just
generate every combination of test masks.

[mlir] Use Use *{Set,Map}::contains (NFC)

[lldb] Use *{Set,Map}::contains (NFC)

[clang-tools-extra] Use *{Set,Map}::contains (NFC)

[mlir] Fix two build warnings (NFC)

/data/llvm-project/mlir/lib/Dialect/Tensor/Utils/Utils.cpp:62:11: error: comparison of integers of different signs: 'int64_t' (aka 'long') and 'size_t' (aka 'unsigned long') [-Werror,-Wsign-compare]
  if (dim >= shape.size())
      ~~~ ^  ~~~~~~~~~~~~
1 error generated.

/data/llvm-project/mlir/lib/Dialect/Tensor/IR/TensorTilingInterfaceImpl.cpp:484:8: error: unused variable 'appendIndex' [-Werror,-Wunused-variable]
  auto appendIndex = [&](Value val, SmallVector<Value> &dynIndices,
       ^
1 error generated.

[mlir][Tensor] Use folded evaluators in tiling implementation of `tensor.pad`.

Reviewed By: springerm

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

[libc] Add instructions for linux headers

Reviewed By: sivachandra

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

Add __builtin_set_flt_rounds

This builtin will be converted to llvm.set.rounding intrinsic
in IR level and should be work with "#pragma STDC FENV_ACCESS ON"
since it changes default FP environment. Users can change rounding
mode via this builtin without introducing libc dependency.

Reviewed by: andrew.w.kaylor, rjmccall, sepavloff, aaron.ballman
Differential Revision: https://reviews.llvm.org/D145765
Signed-off-by: jinge90 <ge.jin@intel.com>

[clang-offload-bundler] Fix error with regex in bundler test

Fix recently introduced error and further generalize
pattern matching for accepted HOST string

[Pipeline] Remove early InstCombine in ThinLTO post link sample profile pipeline

With opaque pointers, all function pointer types are the same, meaning there should be no bitcasts.

Internal benchmarks with SampleFDO look neutral.

This was added in D36333.

Reviewed By: tejohnson, davidxl

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

[clang] Use *{Set,Map}::contains (NFC)

[clang-offload-bundler] Fix test failures and document typo

The recent bundler patch (e48ae0d) introduced a few errors
in two clang/Driver tests, and in the bundler documentation

[llvm] Use *{Set,Map}::contains (NFC)

Mark test modified in e48ae0d as XFAIL for PS4/PS5 until the author can investigate.

The test is failing on the PS4/PS5 bots:
https://lab.llvm.org/buildbot/#/builders/139/builds/37475
https://lab.llvm.org/buildbot/#/builders/216/builds/18354

[MLIR] Update/fix memref region computation for affine.parallel ops

When the affine.parallel op was introduced, affine utilities weren't
extended to handle it. Extending these is straightforward and natural
given that addAffineParallelOpDomain has also been added.
Update/complete memref region compute to account for affine.parallel
ops. Handle failure cleanly.

Add and expose utilities missing for affine.parallel to be consistent
with affine.for.

All of these allow various affine passes to work with a combination of
affine.parallel and affine.for ops.

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

[Target] Use *{Set,Map}::contains (NFC)

Fix split-dwarf-dwp-invalid test to be Windows-path-separator compatible

[BOLT][NFC] Move addRelocation{X86,AArch64} into MCPlusBuilder

The two methods don't belong in BinaryFunction methods.
Move the dispatch tables into target-specific MCPlusBuilder methods.

Reviewed By: rafauler

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

[RISCV][NFC] Combine identical switch cases in TTI

Reviewed By: craig.topper, asb

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

[BOLT][NFC] Simplify MCPlusBuilder::getRegSize

Pre-calculate the register size table in MCPlusBuilder constructor,
similar to `AliasMap`/`SmallerAliasMap` in `initAliases`.

Reviewed By: #bolt, rafauler

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

[compiler-rt][builtins] Support builtins for armv8m.base

This allows building the compiler builtins library for the Armv8-M
Baseline architecture. It can be built in the same way as other
baremetal targets using the appropriate '--target' flag
(e.g. --target=armv8m.base-eabi).

NOTE: As with the other Cortex-M targets, only the builtins library is
supported. There is no support for sanitizers, etc.

The armv8m.base architecture is a superset of armv6m, so adding it to
the cmake files using thumb1_SOURCES is almost enough for it to compile.
Minor changes are needed to divsi3 and udivsi3, because armv8m.base does
have support for div instructions but not mov with an immediate operand.

Reviewed By: MaskRay, peter.smith

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