[llvm][ADT] Fix Any with msvc and lto

llvm::Any had and has several bugs, so we eventually want to replace it
with std::any.

Unfortunately, we cannot do that right now because of bugs in the msvc
standard library that are only fixed in VS 2022 17.4.

When lto is enabled in msvc, constant symbols end up at the same
address, breaking the TypeId implementation of llvm::Any.
Make the TypeId<T>::Id non-const to fix this.

I was able to find an easy reproducer (tried in godbolt with
x64 msvc v19.32 and `/GL` as compiler flags to enable lto):

```c++

template <typename T> struct TypeId {
  // Remove the const here and below to make it work.
  static const char Id;
};

template <typename T> const char TypeId<T>::Id = 0;

template <typename A, typename B>
bool isSame() {
  return &TypeId<A>::Id == &TypeId<B>::Id;
}

class A {};
class B {};

int main() {
  // This should output "is same 0" because the addresses of A's and B's
  // TypeId::Id should be different.
  printf("is same %d\n", isSame<A, B>());
  return 0;
}
```

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

[LAA] Convert test to opaque pointers (NFC)

When converting this test to opaque pointers (and dropping bitcast),
we get improved memory checks. Per fhahn:

> It looks like the difference is due to the logic that determines
> pointer strides in LAA not handling bitcasts. Without the
> bitcasts, the logic now triggers successfully.

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

[AArch64] Add alias predicate-as-counter register for PFALSE

According to:
https://developer.arm.com/documentation/ddi0602/2022-09/
PFALSE should:
"...an assembler must also accept predicate-as-counter register
name for the destination predicate register."

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

AMDGPU: Add more fneg combine tests

[clang][dataflow] Remove stray lines from `Environment::join`

Removes an assertion and a useless line. The assertion seems left over from
earlier debugging and the line that follows is a stray line.

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

ARM: Add baseline tests for fadd with select combine

[clang-tidy][NFC] Replace custom isStatic matcher with the existing isStaticStorageClass

[gn build] Port ca0f4e193b05

[NFC][llvm-exegesis] Try to fix GCC7 build

https://lab.llvm.org/staging/#/builders/235/builds/1121

[AArch64] Add missing v8.8a Non-maskable Interrupts feature

This adds support for the missing Non-maskable Interrupts (FEAT_NMI)
feature from armv8.8-A, which consists of the `ALLINT` pstate register.

This is a second iteration of the patch from D131389, building on top of
the D139925 changes that enable better support for `msr (immediate)`
instructions that take 1-bit immediates.

Contributors:
* David Candler
* Tomas Matheson
* Sam Elliott

Reviewed By: lenary, tmatheson

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

[AArch64] Add new v9.4-A PM pstate system register

This adds support for the new PM pstate system register introduced by
the v9.4-A Exception-based Event Profiling extension (FEAT_EBEP).

The new PM pstate register takes a 1-bit immediate and requires
different values to be specified for the higher bits of the Crm field.
To enable that, this patch creates an explicit separation between the
pstate system registers that take 4-bit and 1-bit immediate operands,
allowing each entry to specify the value for the 3 high bits of Crm.

This also updates other pstate registers to correctly accept 4-bit
immediates, matching their decoding specification from the Arm ARM.
These include: `PAN`,  `UAO`, `DIT` and `SSBS`.

More information about this extension and the new register can be found
at:
* https://developer.arm.com/documentation/ddi0601/2022-09/AArch64-Registers/PM--PMU-Exception-Mask

Contributors:
* Lucas Prates
* Sam Elliott

Reviewed By: lenary

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

[flang] Lowering and runtime support for F08 transformational intrinsics: BESSEL_JN and BESSEL_YN

The runtime implementation uses the recurrence relations

`J(n-1, x) = (2.0 / x) * n * J(n, x) - J(n+1, x)`
`Y(n+1, x) = (2.0 / x) * n * Y(n, x) - Y(n-1, x)`

(see https://dlmf.nist.gov/10.74.iv and https://dlmf.nist.gov/10.6.E1).

Although the standard requires that `N1` and `N2` in `BESSEL_JN(N1, N2, x)`
and `BESSEL_YN(N1, N2, x)` be non-negative, this is not checked in the
runtime functions. This is in keeping with some other compilers which also
return some results when `N1` and/or `N2` are negative.

The special case for `x == 0` is  handled in different runtime functions
for each of `BESSEL_JN` and `BESSEL_YN`. The lowering code checks for this
case and inserts the checks and the appropriate runtime calls in FIR.

The existing tests for the two intrinsics was modified to keep the style
consistent with the additional lowering tests that were added.

[LoopPeel] Expose ValueMap of last peeled iteration. NFC

The value map of last peeled iteration is computed within peelLoop API.
This patch exposes it for callers of peelLoop.
While this is not currently used by upstream passes, we have a usecase
downstream which benefits from this API update. Future users of peelLoop
can also use the ValueMap if needed.

Similar value maps are exposed by other loop utilities such as loop
cloning.

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

Support: Make TypeSize constructors constexpr

This is to enable LLT to be constexpr

[msan] Convert tests to check 'target=...'

Part of the project to eliminate special handling for triples in lit
expressions.

AMDGPU: Convert a few more special case tests to opaque pointers

lower-kernargs.ll needed a switch to use update_test_checks metadata
matching.

AMDGPU: Update some tests to use opaque pointers

vectorize-buffer-fat-pointer.ll required a manual check line fix.
vector-alloca-addrspacecast.ll required a manual fixup of a check
line. partial-regcopy-and-spill-missed-at-regalloc.ll required
re-running update_mir_test_checks. The HSA metadata tests required
avoiding the script touching the type name in the metadata.

annotate-noclobber.ll ran into one update script bug. It deleted a
check line with a 0 offset GEP, moving the following -NEXT check
logically up one line.

AMDGPU: Convert some amdgpu-codegenprepare tests to opaque pointers

amdgpu-late-codegenprepare.ll required running update_test_checks
after converting.

[lsan] Convert tests to check 'target=...'

Part of the project to eliminate special handling for triples in lit
expressions.

[BPFAbstractMemberAccess] Use WeakTrackingVH for Base

The value will be RAUWd, make sure the reference in CallInfo gets
updated.

It seems like this was not a problem without opaque pointers due
to the bitcast in between.

[include-cleaner] Use expansion locations for macros.

Use expansion locations for target symbol decls when finding headers for macros.
Fix: https://github.com/llvm/llvm-project/issues/59392
Differential Revision: https://reviews.llvm.org/D139716

[NFC][llvm-exegesis] Try to fix GCC7 build

https://lab.llvm.org/staging/#/builders/235/builds/1090

[SeparateConstOffsetFromGEP] Remove TypeSize error when collecting constant indices.

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

AMDGPU: Convert some tests to opaque pointers

These required update_mir_test_checks.

Fix tests for commit 658ed9547cdd6657895339a6c390c31aa77a5698.

[BPF] Restore failing offset-reloc-cast-struct tests (NFC)

After opaque pointer conversion these tests fail with a use after
free under asan, due to bugs in BPFAbstractMemberAccess. For now,
restore the tests to unbreak build bots.

[lit] Script to automate use of %(line-n). Use in CodeComplete tests.

Tests where the RUN-lines/CHECK-ed output refer to line numbers in the test
file are a maintenance burden, as inserting text in the appropriate place
invalidates all the subsequent line numbers.

Lit supports %(line+n) for this, and FileCheck supports [[@LINE+N]].
But many existing tests don't make use of it and still need to be modified.

This commit adds a script that can find line numbers in tests according to a
regex and replace them with the appropriate relative-line reference.
It contains some options to avoid inappropriately rewriting tests where absolute
numbers are appropriate: a "nearby" threshold and a refusal by default to
replace only some matched line numbers.

I've applied it to CodeComplete tests, this proves the concept but also are the
single worst group of tests I've seen in this respect.
These changes are likely to hit merge conflicts, but can be regenerated with:

```
find ../clang/test/CodeCompletion/ -type f | grep -v /Inputs/ | xargs ../llvm/utils/relative_lines.py --verbose --near=20 --pattern='-code-completion-at[ =]%s:(\\d+):' --pattern='requires fix-it: {(\d+):\d+-(\d+):\d+}'
````

As requested in https://reviews.llvm.org/D140044

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

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

[SystemZ] Fix test (NFC)

Broken during opaque pointer conversion. I did not notice because
it requires -Drun_long_tests=1 to run.

Run the test through instnamer so updating it works properly.

InstCombine: Match pattern that appears in clang's __builtin_isnormal

and (fcmp ord x, 0), (fcmp u* x, inf) -> fcmp o* x, inf
and (fcmp ord x, 0), (fcmp u* fabs(x), inf) -> fcmp o* x, inf

Clang emits this peculiar pattern as an isfinite check in
__builtin_isnormal which can be simplified. We should fix clang to
emit this in the first place, but should also fold it here.

InstCombine: Add baseline tests for and (fcmp ord x), (fcmp u* x)

[include-cleaner] Handle dependent type members in AST.

Handles dependent type members in AST.

Fix: https://github.com/llvm/llvm-project/issues/59354
Differential Revision: https://reviews.llvm.org/D139409

[gn build] Port

Fix abs labs and llabs to work in C code.

InstCombine: Add baseline test for pattern in clang's isnormal

Clang emits this peculiar pattern as an isfinite check in
__builtin_isnormal which can be simplified. We should fix clang to
emit this in the first place, but should also fold it here.

[InstCombine][NFC] Add tests of combining ZExt(B-A) + ZExt(A) to ZExt(B)

Fix host call to nohost function with host variant.

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

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

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

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

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

[Thumb] Convert tests to opaque pointers (NFC)

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

[SystemZ] Convert test to opaque pointers (NFC)

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

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

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

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

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

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

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

[analyzer] Fix crash inside RangeConstraintManager.cpp introduced by D112621

It seems like `LHS` and `RHS` could be empty range sets.
This caused an assertion failure inside RangeConstraintManager.

I'm hoisting out the check from the function into the call-site.
This way we could assert that we only want to deal with non-empty range
sets.

The relevant part of the trace:
```
 #6 0x00007fe6ff5f81a6 __assert_fail_base (/lib64/libc.so.6+0x2f1a6)
 #7 0x00007fe6ff5f8252 (/lib64/libc.so.6+0x2f252)
 #8 0x00000000049caed2 (anonymous namespace)::SymbolicRangeInferrer::VisitBinaryOperator(clang::ento::RangeSet, clang::BinaryOperatorKind, clang::ento::RangeSet, clang::QualType) RangeConstraintManager.cpp:0:0
 #9 0x00000000049c9867 (anonymous namespace)::SymbolicRangeInferrer::infer(clang::ento::SymExpr const*) RangeConstraintManager.cpp:0:0
#10 0x00000000049bebf5 (anonymous namespace)::RangeConstraintManager::assumeSymNE(llvm::IntrusiveRefCntPtr<clang::ento::ProgramState const>, clang::ento::SymExpr const*, llvm::APSInt const&, llvm::APSInt const&) RangeConstraintManager.cpp:0:0
#11 0x00000000049d368c clang::ento::RangedConstraintManager::assumeSymUnsupported(llvm::IntrusiveRefCntPtr<clang::ento::ProgramState const>, clang::ento::SymExpr const*, bool) (../../main-github/llvm/build-all/bin/clang+0x49d368c)
#12 0x00000000049f0b09 clang::ento::SimpleConstraintManager::assumeAux(llvm::IntrusiveRefCntPtr<clang::ento::ProgramState const>, clang::ento::NonLoc, bool) (../../main-github/llvm/build-all/bin/clang+0x49f0b09)
#13 0x00000000049f096a clang::ento::SimpleConstraintManager::assume(llvm::IntrusiveRefCntPtr<clang::ento::ProgramState const>, clang::ento::NonLoc, bool) (../../main-github/llvm/build-all/bin/clang+0x49f096a)
#14 0x00000000049f086d clang::ento::SimpleConstraintManager::assumeInternal(llvm::IntrusiveRefCntPtr<clang::ento::ProgramState const>, clang::ento::DefinedSVal, bool) (../../main-github/llvm/build-all/bin/clang+0x49f086d)
#15 0x000000000492d3e3 clang::ento::ConstraintManager::assumeDual(llvm::IntrusiveRefCntPtr<clang::ento::ProgramState const>, clang::ento::DefinedSVal) (../../main-github/llvm/build-all/bin/clang+0x492d3e3)
#16 0x0000000004955b6d clang::ento::ExprEngine::evalEagerlyAssumeBinOpBifurcation(clang::ento::ExplodedNodeSet&, clang::ento::ExplodedNodeSet&, clang::Expr const*) (../../main-github/llvm/build-all/bin/clang+0x4955b6d)
#17 0x00000000049514b6 clang::ento::ExprEngine::Visit(clang::Stmt const*, clang::ento::ExplodedNode*, clang::ento::ExplodedNodeSet&) (../../main-github/llvm/build-all/bin/clang+0x49514b6)
#18 0x000000000494c73e clang::ento::ExprEngine::ProcessStmt(clang::Stmt const*, clang::ento::ExplodedNode*) (../../main-github/llvm/build-all/bin/clang+0x494c73e)
#19 0x000000000494c459 clang::ento::ExprEngine::processCFGElement(clang::CFGElement, clang::ento::ExplodedNode*, unsigned int, clang::ento::NodeBuilderContext*) (../../main-github/llvm/build-all/bin/clang+0x494c459)
#20 0x000000000492f3d0 clang::ento::CoreEngine::HandlePostStmt(clang::CFGBlock const*, unsigned int, clang::ento::ExplodedNode*) (../../main-github/llvm/build-all/bin/clang+0x492f3d0)
#21 0x000000000492e1f6 clang::ento::CoreEngine::ExecuteWorkList(clang::LocationContext const*, unsigned int, llvm::IntrusiveRefCntPtr<clang::ento::ProgramState const>) (../../main-github/llvm/build-all/bin/clang+0x492e1f6)
```

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

[ValueTracking] Consider single poison operands in propgatesPoison.

This patch updates propgatesPoison to take a Use as argument and
propagatesPoison now returns true if the passed in operand causes the
user to yield poison if the operand is poison

This allows propagating poison if the condition of a select is poison.
This helps improve results for programUndefinedIfUndefOrPoison.

Reviewed By: nikic

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

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

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

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

[AMDGPU][CodeGen] Support raw format TFE buffer loads other than byte, short and d16 ones.

Reviewed By: arsenm

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

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

[mlir][Bazel] Add ModuleImport sources to FromLLVMIRTranslation target.

[X86] Fix SLM uops counts for AES instructions

Based off llvm-exegesis captures, confirmed with uops.info

[X86] Add default LoadUOps argument to Intel models WriteResPair macro

This will make it easier to override the folded uop count on a class-by-class basis

[flang] Fix llvm::Optional warning caused by D140220

Using llvm::Optional::value() was just deprecated in LLVM.
Remove the usage that was added by D140220 and replace it by an assert.

https://lab.llvm.org/buildbot/#/builders/160/builds/14222

[WebAssembly] Fix crash when selecting 64 bit lane extract operand

The tablegen patterns on vector_extract only match i32 constants, but
on wasm64 these come in as i64 constants. In certain situations this
would cause crashes whenever it couldn't select an extract_vector_elt
instruction.
Rather than add duplicate patterns for every instruction, this just
canonicalizes the constant to be i32 when lowering.
Fixes https://github.com/llvm/llvm-project/issues/57577

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

[Bitcode] Convert tests to opaque pointers (NFC)

[mlir][llvm] Move LLVM IR import into separate file (NFC).

The revision renames the Importer to ModuleImport and moves the class
out of the ConvertFromLLVMIR.cpp file into ModuleImport.h and
ModuleImport.cpp. Additionally, it introduces two helper methods
on the ModuleImport class that convert functions and globals, and it
merges the translateLLVMIRToModule function into the
registerFromLLVMIRTranslation function to match the design of
the MLIR to LLVM IR export.

This restructuring is a step towards the file structure of the export
and a preparation for an extensible import
https://discourse.llvm.org/t/rfc-extensible-llvm-ir-import/67256/6 that
uses a dialect interface to import intrinsics and metadata.

Reviewed By: ftynse

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

[flang] Lower statement function references in HLFIR

Enable lowering of statement function references in HLFIR.  This follows
the same principle as statement function lowering with the current
lowering:
- Actual arguments are lowered and mapped to the statement function
  dummy symbols.
- "HostAssociated" symbols are mapped to their host values (these are
  the symbols referred to inside the statement function expressions that
  are not statement function dummies. e.g: `x` in `stmt_func(i) =
  x(i)`).
- The statement function expression is evaluated.

evaluate::SetLength has to be lowered to deal with statement functions
returning characters since the front-end is generating one to ensure the
statement function expression value is trimmed/padded to match the statement
function declared type.

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

[lldb] Modernize sprintf in FormatEntity.cpp

Avoid buffer overflows with large indexes, and spurious nul characters
with small ones.

[MLIR][Bufferization] Remove extra trailing spaces (NFC)

[mlir][vector] Add scalar vector xfer to memref patterns

These patterns devectorize scalar transfers such as vector<f32> or vector<1xf32>.

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

[mlir][vector] Fix error handling in VectorizationState::initState

This function used to create new ops even if the vectorization failed. Those ops were then folded away. This caused a failure of the GreedyPatternRewriter, which no longer terminated (each time the IR is modified => one more iteration).

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

[mlir][Bazel] Add missing dependency to TensorDialect.

[CLANG] XFAIL c-strings.c & volatile-1.c AArch64/Windows

c-strings.c was marked XFAIL for msvc ABI on AArch64/Windows platform.
But it is failing due to alignment issue on WoA for both msvc and gnu
gnu ABIs. I am going to mark them as XFAIL for both.

[mlir] optionally allow repeated handles in transform dialect

Some operations may be able to deal with handles pointing to the same
operation when the handle is consumed. For example, merge handles with
deduplication doesn't actually destroy payload operations and is
specifically intended to remove the situation with duplicates. Add a
method to the transform interface to allow ops to declare they can
support repeated handles.

Reviewed By: springerm

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

Revert "[lldb] Remove redundant .c_str() and .get() calls"

This reverts commit fbaf48be0ff6fb24b9aa8fe9c2284fe88a8798dd.

This has broken all LLDB buildbots:
https://lab.llvm.org/buildbot/#/builders/68/builds/44990
https://lab.llvm.org/buildbot/#/builders/96/builds/33160

[mlir] Apply ClangTidy readability finding.

Use empty() instead of checking for size 0.

[flang] Add hlfir.set_length operation

This will implement evaluate::SetLength where the length of
a character entity is changed (with trimming and padding).

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

[flang][NFC] move getIntIfConstant into FIROpsSupport.h

The motivation is to have it accessible in HLFIROps.cpp to
use it in hlfir.set_length builder to build the result length
type as best as possible.

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

[Examples] Fix build (NFC)

Can't use VLA at file scope.

[include-cleaner] Fix a missing review comment.

I forgot to add the change to the commit when committing.

[MLIR][Bufferization] Introduce `EmptyTensorToAllocTensorOp`

Introduce a new transform operation to replace `tensor.empty` with
`alloc_tensor` operations. The operation is a pass-through if the target
operation is already a `alloc_tensor`; otherwise, it expects a
`tensor.empty` as a target. Currently, it does not return any results.

The operation is expected to run before `one_shot_bufferize` as
`one_shot_bufferize` rejects `tensor.empty`.

Reviewed By: springerm

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

[Bazel] Remove define HAVE_LSEEK64 to match cmake config.

[include-cleaner] Fix the member-expr-access usage for sugar type.

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

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

Fix 'underline too short' failure

[Intrinsic] Rename flt.rounds intrinsic to get.rounding

Address the inconsistency between FLT_ROUNDS_ and SET_ROUNDING SDAG
node. Rename FLT_ROUNDS_ to GET_ROUNDING and add llvm.get.rounding
intrinsic to replace flt.rounds.

Reviewed By: nikic

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

[mlir][transform] Add PackedOrDynamicIndexList helper

This customer parser/printer is similar to DynamicIndexList, but has special syntax for the case where one handle represents the entire list.

Example:
```
// Regular index list
[10, 20, %val]

// Packed handle (no square parentheses)
%val
```

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

[AIX][BigArchive] Treat the archive is empty if the first child member offset is zero

If the archive contains free list and contains no member file, the buffer length doesn't equal to length of the header.

Reviewed By: Esme, DiggerLin, #powerpc

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

[mlir][python] llvm::Optional::value => operator*

And convert it to std::optional while updating.

PPC: Implement null target streamer

[InstCombine] `sinkNotIntoOtherHandOfLogicalOp()`: don't forget to re-set insert position

Several bots are unhappy, and this appears to be the reason:
we might be inserting into wrong basic block,
one that does not dominate the I.

[InstCombine] `sinkNotIntoOtherHandOfLogicalOp()`: allow extra invertible uses of hand-to-invert

[NFC][InstCombine] Improve test coverage for invertible extra uses of hands of logical op

While there, reduce bitwidth, we really don't care about testing i32 specifically.

[InstCombine] Support sinking `not` into logical operand with invertible hands

The important bit here is that we gracefully handle other uses,
iff they can be adapted to inversion.

I'll note, the previous logic was actively bad,
it increased instruction count since it didn't actually ensure
that the inversions happened.

[NFC][InstCombine] Add tests for sinking `not` into logical ops with hands with extra (but invertible) uses

[CodeGen] Include llvm/CodeGen/DFAPacketizer.h

This patch teaches MachinePipeliner.h to include
DFAPacketizer.h so that the header file is self contained.

Without this patch, a C++ source file that only includes
MachinePipeliner.h does not compile because the forward declaration of
DFAPacketizer is not enough for:

  llvm::SmallVector<std::unique_ptr<DFAPacketizer>> DFAResources;

[CodeGen] Include MachineInstr.h

This patch teaches DbgEntityHistoryCalculator.h to include
MachineInstr.h so that the header file is self contained.

Without this patch, a C++ source file that only includes
DbgEntityHistoryCalculator.h does not compile because:

  PointerIntPair<const MachineInstr *, 1, EntryKind> Instr;

wants to know the alignment of llvm::MachineInstr:

  llvm/include/llvm/Support/PointerLikeTypeTraits.h:61:28: error:
  invalid application of 'alignof' to an incomplete type
  'llvm::MachineInstr'
          detail::ConstantLog2<alignof(T)>::value;
                               ^~~~~~~~~~

[InstCombine] Try to sink `not` of one operand of logical operation into another hand

Matches what we do for binary operations, but a special care needs
is needed to preserve operand order, as the logical operations
are not strictly commutative!

[NFC][InstCombine] Add tests with invertible hands of logical operators

Revert "[APSInt] Fix bug in APSInt mentioned in https://github.com/llvm/llvm-project/issues/59515"

This reverts commit 7859d6e79ca90df2f3f206192a1dfa89e3cb10f1.

Signed-off-by: Peter Rong <PeterRong96@gmail.com>

[gn] try porting 07af0e2d3e84 even more

Possibly fixes tests on Linux. This corresponds to
`export_executable_symbols_for_plugins` calls in CMake.

[APSInt] Fix bug in APSInt mentioned in https://github.com/llvm/llvm-project/issues/59515

Also provide a `tryExtValue()` API like APInt did in D139683

Reviewed By: RKSimon

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