[InstCombine] Canonicalize icmp eq pow2 more thoroughly

We currently already canonicalize icmp eq (%x & Pow2), Pow2 to
icmp ne (%x & Pow2), 0. This patch generalizes the fold based on
known bits.

In particular, this allows us to handle comparisons against
!range !{i64 0, i64 2} loads, which addresses an optimization
regression in Rust caused by 8df376db7282b955e7990cb8887ee9dcd3565040.

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

[clang-tidy] Correctly handle evaluation order of designated initializers.

As designated initializers show up only in the syntactic form of the
InitListExpr, we need to make sure we're searching both forms of the
InitListExpr when determining successors in the evaluation order.

This fixes a bug in bugprone-use-after-move where previously we erroneously
concluded that two designated initializers were unsequenced. The newly added
tests fail without the fix.

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

[mlir][llvm] Add fastmathFlags to SelectOp

`select` has fastmath flags, which were missing from the LLVM dialect op
definition.

Reviewed By: ftynse, dcaballe, gysit

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

[LoongArch] Emit bytepick for picking from concatenation of two values

It seems the ISA manual's pseudo-code description for the
`BYTEPICK.[WD]` instructions is inaccurate; the behavior described here
should be correct though. The instructions' names are misleading too
(they pick full GRLen-wide words instead of bytes; they just index by
bytes) but let's stick to the official names for now.

Reviewed By: SixWeining

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

[LoongArch] Add baseline tests for `bytepick` codegen. NFC

Reviewed By: SixWeining

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

[mlir] Fix scf.for with signless iterations print/parse

There was accidentally a different form used for printing and parsing.

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

[LSAN][HWASAN] Turn on leak sanitizer in HWASAN for Linux

Reviewed By: vitalybuka

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

[HWASAN] Fix a memory leak in realloc-test.cpp

Reviewed By: vitalybuka

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

[RISCV][NFC] Add more floating point tests for SLP vectorization

Reviewed By: reames

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

[RISCV][NFC] Add tests for SLP vectorization of smin/smax/umin/umax

Reviewed By: reames

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

[libc][docs] Add a section about allocations and deallocations to the style doc.

Fixes #59277 - The main part of that bug has already been addressed. This commit
just adds documentation.

Reviewed By: jeffbailey

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

[libc][docs] Move the link to "Compiler Support" under "Status".

Also, fixed a minor typo in compiler_support.rst.

Reviewed By: jeffbailey, gchatelet

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

The test added in d8690bc requires ZLIB, so only run the test if LLVM_ENABLE_ZLIB is set.

This will fix buildbots that fail because they do not have ZLIB installed such as
https://lab.llvm.org/buildbot/#/builders/216/builds/18424

[libc] Add missing return statements to wrapper functions

Summary:
I forgot to add return statements to these memory comparison functions.
This should hopefully resolve some BB errors.

[RISCV]Optimize (riscvisd::select_cc x, 0, ne, x, 1)

This patch reduces the number of unpredictable branches.

Reviewed By: craig.topper

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

[libc] Do not attempt to determine CPU features in GPU mode

Summary:
We don't use these features in the GPU build, trying to determine them
can cause errors. We should just return early if this is the case.

[Clang][LoongArch] Implement patchable function entry

Similar to D98610 for RISCV.

This is going to be required by the upcoming Linux/LoongArch
[[ https://git.kernel.org/linus/4733f09d88074 | support for dynamic ftrace ]].

Reviewed By: SixWeining, MaskRay

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

[libc] Add aliases to C memory functions for integration tests

The integration tests require the C memory functions as the compiler may
emit calls to them directly. The tests normally use the `__internal__`
variant that is built for testing, but these memory functions were
linked directly to preserve the entrypoint. Instead, we forward delcare
the internal versions and map the entrypoints to them manually inside
the integration test. This allows us to use the internal versions of
these files like the rest of the test objects.

Reviewed By: sivachandra

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

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

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

[Lex] Use false instead of 0 (NFC)

[llvm-profdata] Add more unit tests to check --output-size-limit feature when compression is enabled

Add unit tests for ExtBinary format with compression. This patch doesn't imply there's a bug in the existing implementation,
but as a precaution that planned changes to SampleProfileReader may cause it to break.

Reviewed By: snehasish

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

[scudo] Add a method to force release everything.

The force flag to releaseToOSMaybe does not release everything
since it is an expensive operation. Modify the release flag to
have three states: normal, force, forceall. Force behaves the same
as setting Force to true from before this change. Forceall will
release everything regardless of how much time it takes, or
how much there is to release.

In addition, add a new mallopt that will call the release function
with the forceall flag set.

Reviewed By: Chia-hungDuan

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

[ADT][mlir] Fix gcc build error

Add `template` to fix a buildbot:
https://lab.llvm.org/buildbot/#/builders/199/builds/18363.

This is a post-commit fix for https://reviews.llvm.org/D144503,
submitted as a0a76804c4b5.

Add a Debugger interruption mechanism in conjunction with the
Command Interpreter mechanism.

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

[ADT] Allow `llvm::enumerate` to enumerate over multiple ranges

This does not work by a mere composition of `enumerate` and `zip_equal`,
because C++17 does not allow for recursive expansion of structured
bindings.

This implementation uses `zippy` to manage the iteratees and adds the
stream of indices as the first zipped range. Because we have an upfront
assertion that all input ranges are of the same length, we only need to
check if the second range has ended during iteration.

As a consequence of using `zippy`, `enumerate` will now follow the
reference and lifetime semantics of the `zip*` family of functions. The
main difference is that `enumerate` exposes each tuple of references
through a new tuple-like type `enumerate_result`, with the familiar
`.index()` and `.value()` member functions.

Because the `enumerate_result` returned on dereference is a
temporary, enumeration result can no longer be used through an
lvalue ref.

Reviewed By: dblaikie, zero9178

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

[Clang][AIX][p] Manually Claim -p in front end

The current implementation of `-p` does not claim the argument once it
is passed. Since it pushes `-pg` directly, it is only ever referred to
again when linking. As a result, when compiling with `-S`, the compiler
warns that `-p` goes unused even though that is not the case.

With this patch, if both `-p` and `-pg` are passed, the argument that is
passed second will take precedence. `-p` will still throw an error on
unsupported platforms, regardless of precedence.

This revision includes a test case, which has been placed in
`clang/test/Driver/zos-profiling-error.c`. As a result,
`zos-profiling-error.c` has been renamed to `ibm-profiling.c`. This
revision also passes `clang/test/Driver/aix-ld.c`.

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

[lldb] Update PythonDataObjectsTests for new exception formatting

PythonDataObjectsTest.TestExceptions started failing because the output
of the python traceback printers is now consistent between python and
cpython [1]. Work around the issue by supporting both variants.

Thanks to Ismail for identifying the root cause.

[1] https://github.com/python/cpython/issues/85203

[libc][NFC] Clean up clang-tidy warnings for `src/__support` and `src/math`.

Clean up some warnings from running libc-lint for these folders.

Reviewed By: michaelrj, sivachandra

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

ConstantFolding: Minor cleanups for is_fpclass

Revert "[RISCV] Enable interleaved access vectorization"

This reverts commit acc03ad10af4f379a644e3956cb9aca54e40696c.

[RISCV] Enable interleaved access vectorization

The loop vectorizer supports generating interleaved loads and stores via
shuffle patterns for fixed length vectors.
This enables it for RISC-V, since interleaved shuffle patterns can be
lowered to vlseg/vsseg in https://reviews.llvm.org/D145022

Reviewed By: reames

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

[Clang][Sema] Fix incorrect deletion of default constructors for some unions

If a union has explicit initializers for some members, we shouldn't delete
its default constructor.
Fixes https://github.com/llvm/llvm-project/issues/48416.

Reviewed By: erichkeane

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

[AArch64] Add hex comments to mov-imm spellings in the InstPrinter

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

Revert "[AArch64] Add hex comments to mov-imm spellings in the InstPrinter"

This reverts commit 1def3141135c072a1d3e51e82e113dd67b0def97.

[AArch64] Add hex comments to mov-imm spellings in the InstPrinter

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

[AArch64] Change GeneratePerfectShuffle to return one destination operand for zip and transpose operations.

The tests added where crashing because zip instruction was returning two destination operands. ZIP according to arm returns only one destination operand.

Reviewed By: dmgreen, fhahn

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

Revert "[lldb] Change dwim-print to default to disabled persistent results"

This reverts commit 8bad4ae679df6fc7dbd016dccbd3da34206e836b.

[SCEV] Do not strengthen nuw/nsw flags during get[Zero,Sign]ExtendedExpr.

Modifying AddRecs when constructing other expressions can lead to
surprising changes. It also seems like it is not really beneficial i
most cases.

At the moment, there's a single regression, but we still might be able
to improve the flags at AddRec construction.

Might help with the issue discussed in D143409.

Reviewed By: mkazantsev

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

[mlir][sparse] Modify the pivot selection method for quick sort.

Previously, we choose the median of three values. We now choose the median of
five values when the number of values being sorted exceed a threshold
(currently 100). This is similar to std::sort.

Reviewed By: aartbik

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

[lldb] Change dwim-print to default to disabled persistent results

Change `dwim-print` to now disable persistent results by default, unless requested by
the user with the `--persistent-result` flag.

Ex:

```
(lldb) dwim-print 1 + 1
(int) 2
(lldb) dwim-print --persistent-result on -- 1 + 1
(int) $0 = 2
```

Users who wish to enable persistent results can make and use an alias that includes
`--persistent-result on`.

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

Reland [StandardInstrumentations] Check function analysis invalidation in module passes as well

See comments for why we now need to pass in the MAM instead of the FAM.

Reviewed By: nikic

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

Revert "[StandardInstrumentations] Check function analysis invalidation in module passes as well"

This reverts commit d6c0724eb158efcdcd4e31289dcb954a441c4939.

Breaks clang/flang builds.

[StandardInstrumentations] Check function analysis invalidation in module passes as well

See comments for why we now need to pass in the MAM instead of the FAM.

Reviewed By: nikic

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

[StandardInstrumentations] Verify function doesn't change if analyses are preserved

Reuse StructuralHash and allow it to be used in non-expensive checks builds.

Move PreservedAnalysisChecker further down StandardInstrumentations so other Instrumentations (e.g. printing) have a chance to run before PreservedAnalysisChecker crashes.

Reviewed By: nikic

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

[StandardInstrumentations] Rename -verify-cfg-preserved -> -verify-analysis-invalidation

In preparation for adding more checks under this flag.

Reviewed By: nikic

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

[BOLT][NFC] Simplify preprocessProfile

Move out prepareToParse lambda, generalize it to handle mem events perf process.

Reviewed By: #bolt, rafauler

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

[mlir][sparse] Updating `Merger::foreachTensorLoopId` to take `LatPointId`

Since all callsites of `foreachTensorLoopId` would simply look up the `LatPointId` to extract its `BitVector`, it's cleaner to let the `Merger` handle that instead.  This seems to better capture the intent of the `foreachTensorLoopId` method, and improves decoupling (since it removes a place that leaks the implementation detail that we use `BitVector`).

Reviewed By: aartbik

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

[Dexter] Add a simple logging class to Dexter

Adds a basic logging class to Dexter that uses the existing PrettyOutput
class for printing and supports 3 levels of verbosity (note, warning,
error). Intended to consolidate the logging logic for Dexter into one
place, removing the need for conditional log statements and making it
easier for us later if we wish to use a more complete logging class.

Reviewed By: Orlando

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

[gn build] Manually port d505d20

[MSVC][dllexport/dllimport] Propagate a dllexport/dllimport attribute to template baseclass

For the Playstation platform, mimick MSVC in propagating dllexport/dllimport attributes
to an instantiated template base class.

Reviewed By: hans

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

[Debugify/Strip] Fix returned PreservedAnalyses

[WPD] Fix PreservedAnalyses value after runForTesting()

[wasm] Silence 'not all control paths return a value' warning when
building with MSVC on Windows

[DebugInfo][MSF] Silence 'not all control paths return a value' warning
when building with MSVC on Windows

[X86] lzcnt-cmp.ll - enable CMOV on 32-bit LZCNT tests

There are no 32-bit targets that have LZCNT but not CMOV, and this allows us to test the straight line i64 pattern - otherwise we're doing the same branchy code as the 32-bit BSR test

[FuncSpec][NFC] Command line option renaming.

Standardize all options with 'funcspec' prefix and shorter abreviations.

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

[clang][RISCV][test] Add test coverage for _Float16 ABI lowering

By the psABI, any test case where a FPR would be used for a float, it
should also be used if you replaced that float with a _Float16. This
doesn't hold true in current Clang for the special cases in the FP
calling convention involving structs. This patch doesn't attempt to fix
that, simply to add coverage. D145074 contains the fix.

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

[mlir][memref] Fold subview into GPU subgroup MMA load/store ops

This commits adds support for folding subview into GPU subgroup
MMA load/store ops.

Reviewed By: ThomasRaoux

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

[DAG] Don't fold zext(logicalshift(zext(x),c)) -> logicalshift(zext(x),c) if the outer zext is free

Avoid widening the shift to a bigger type if the zext would be free anyway

Pulled out of D146121

[DWARFLinkerParallel] add AddressesMap interface.

This patch is extracted from D96035. It adds AddressesMap map interface
to the DWARFLinkerParallel library. This interface mostly match with the
paired interface from the DWARFLinker library, except that it does
not depend on DIEInfo class.

Reviewed By: JDevlieghere

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

[Inliner] Assign dummy debug location to the memcpy for byval argument

A similar fix to D133095.

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

Reviewed By: aprantl

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

[libc++] Fixes accidental CI breakage.

[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