[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

[InstCombine] Try to fold `not` into `cmp` iff other users of `cmp` are freely invertible

There is still some such patterns that require collaboration
of folds to handle,that we don't currently do.

[NFC][PatternMatching] Promote `m_LogicalOp` matchers into `PatternMatch.h`

[MC] Use `MCRegister` instead of `unsigned` in `MCTargetAsmParser`

Reviewed By: MaskRay

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

[CMake] Fix LoongArchTests -DBUILD_SHARED_LIBS=on builds

Similar to 1b9cd51d55b33cfaf68e21fa5396539ca54e5324

Revert "[clang] Convert OptionalFileEntryRefDegradesToFileEntryPtr to std::optional"

This reverts commit 8f0df9f3bbc6d7f3d5cbfd955c5ee4404c53a75d.

The Optional*RefDegradesTo*EntryPtr types want to keep the same size as
the underlying type, which std::optional doesn't guarantee. For use with
llvm::Optional, they define their own storage class, and there is no way
to do that in std::optional.

On top of that, that commit broke builds with older GCCs, where
std::optional was not trivially copyable (static_assert in the clang
sources was failing).

[libc++][CI] Fixes build failures.

Some clang diagnostics have changed causing build failures.

Reviewed By: #libc, Mordante

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

[PoisonChecking] Add tests with selects.

This adds test coverage for a suggestion in D111643.

AMDGPU/GlobalISel: Use ptrtoint to legalize constant 32-bit addrspacecast

This was trying to merge 2 32-bit pointers into a 64-bit pointer. The
artifact combiner was assuming merges to pointers use scalar sources,
and ended up inserting invalid bitcast from a pointer to a scalar. It
should probably be a verifier error to have pointer merge sources with
a pointer result.

Fixes verifier errors with EXPENSIVE_CHECKS.

llvm-profgen: Fix use of stats to be under LLVM_ENABLE_STATS

This caused a -Wunused-variable warning in a without-assert+with-stats
build (because the stats were included but their use was not).

Stat use is meant to be gated by LLVM_ENABLE_STATS which can be set
independently of assertions.

[llvm-exegesis][X86] Explicitly not support `WRFSBASE` opcode.

We can't serialize if for latency measurements, and when measuring uops,
it crashes so hard even `CrashRecoveryContext` doesn't stop it.

Looks like *this* was the last crasher, now `--opcode-index=-1`
succeeds for all three benchmark modes here.
At least with Duplication repetitor.

[NFC][llvm-exegesis] Improve `getOpcodesOrDie()`

We already have opcode name -> opcode index map, use it.
Reserve memory where appropriate.

[llvm-exegesis] Benchmark: gracefully handle lack of configurations to run

Otherwise the progress meter would assert.

[libc] Make string functions buildable with GCC

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

Use -Wstrict-prototypes with clang only

[llvm-exegesis] Fix 'min' repetition mode in presence of missing measurements

This was a regression from 17e202424c021fd903950fec7a8b6cca2d83abce.
Previously we'd gracefully handle missing measurements,
but that handling got accidentally lost during the code move,
and we'd assert.

What we want to do, is to discard all measurements (from all repetitors
in a given config) if any of them failed, but do append the snippet,
and do emit the empty measurement.

[NFC][llvm-exegesis] Benchmark: move DumpObjectToDisk handling into `runConfiguration()`

`getRunnableConfiguration()` may be executed in parallel,
and then this the output would become even less useful.

[gn] port 7d2c1150d31b better

[mlir][Linalg] NFC - Add C++ builder to TileOp

[InstCombine] fold flooring sdiv by power-of-2 to ashr

It's a bigger match than usual, but I have not found any
sub-patterns that reduce:
(X / DivC) + sext ((X & (SMin | (DivC - 1)) >u SMin) --> X >>s log2(DivC)

https://alive2.llvm.org/ce/z/MJzlhl

Fixes issue #55741

[InstCombine] add/adjust tests for flooring div; NFC

AMDGPU/R600: Special case addrspacecast lowering for null

Due to poor support for non-0 null pointers, clang always emits
addrspacecast from a null flat constant for private/local null. We can
trivially handle this case for old hardware.

Should fix issue 55679.

AMDGPU: Lower addrspacecast on gfx6

Fixes inconsistent handling of constant-32bit case. Turns out we can
lower all the casts just fine, it's just accessing the flat results
that's a problem.

[gn] port 7d2c1150d31bb

[gn build] Port rest of 07af0e2d3e84

Test now passes, at least on macOS.

[llvm-objdump][AArch64] Fix ADRP target label calculation

This patch makes ADRP target label address calculations the same as
label address calculations (see AArch64InstPrinter::printAdrpLabel()).

Otherwise the target label looks misleading as ADRP's immediate offset is,
actually, not an offset to this PC, but an offset to the current PC's
page address in pages.

See for example, `llvm-objdump/ELF/AArch64/pcrel-address.yaml`.
Before this patch the target label `<_start+0x80>` represents the
address `0x200100 + 0x80` while `0x220000` is expected.

Note that with this patch llvm-objdump output matches GNU objdump.

Reviewed By: simon_tatham

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

[gn build] Port some of 07af0e2d3e84

Enough to get the build fixed, but doesn't add the plugin yet, so the test
fails for now.

[gn] port ae3e228af7

[InstCombine] canonicalize insertelement order based on index

This puts lower insert indexes before higher. This is independent
of endian, so it requires an adjustment to a fold added with
4446f71ce392, but it makes that fold more robust.
That's also where this patch was suggested - D139668.

This matches what we already do in DAGCombiner, but there is one
more constraint because there's an existing canonicalization for
insert-of-scalar-constant. I'm not sure if that is still needed,
so it may be adjusted/removed as a follow-up.

[InstCombine] add tests for flooring division; NFC

issue #57741

[InstCombine] avoid IR values named 'tmp' in tests; NFC

The auto-generation CHECK script warns of possible conflict on these files.

[InlineAdvisor] Fix dependencies for InlineAdvisorPlugin

Reviewed By: akyrtzi

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

[C++20][Modules] Elide unused guard variables in Itanium ABI module initializers.

For the Itanium ABI, we emit an initializer for each module.  This is responsible
for handling initialization of global vars.  Relates to P1874R1.

The initializer has a known mangling and is automatically called from any TU that
imports a module. Since, at present, the importer has no way to determine that an
imported module does not require an initializer, we generate the initializer for
all cases (even when it is empty).

Initializers must be run once, with the ordering guaranteed by the import graph
and this is ensured in the current code by addition of a guard variable.

In the case that a module has no requirement for global initializers, and also does
not import any other modules, we can elide the guard variable.

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

Include <optional> instead of "llvm/ADT/Optional.h"

This is part of an effort to migrate from llvm::Optional to
std::optional:

https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716

[AAPointerInfo] handle multiple offsets in PHI

Previously reverted in 8b446ea2ba39e406bcf940ea35d6efb4bb9afe95

Reapplying because this commit is NOT DEPENDENT on the reverted commit
fc21f2d7bae2e0be630470cc7ca9323ed5859892, which broke the ASAN buildbot.
See https://reviews.llvm.org/rGfc21f2d7bae2e0be630470cc7ca9323ed5859892 for
more information.

The arguments to a PHI may represent a recurrence by eventually using the output
of the PHI itself. This is now handled by checking for cycles in the control
flow. If a PHI is not in a recurrence, it is now able to report multiple offsets
instead of conservatively reporting unknown.

Reviewed By: jdoerfert

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

Reland 3nd attempt:  [lld-macho] Fix bug in reading cpuSubType field.

This reverts commit 09c5aab7f88178c1af92de0b00417416da9db6c1.

New changes:
Temporarily skip checking the output bundle's cpu/cpu-subtype
Suspected there's a bug in selecting targets which caused the produced bundle
to be arm64 bundle (even though it was specifically linked with -arch x86_64).

The current test that link succeeded should be sufficient, because
it would have failed with "unable to find matching tagets" prior to this patch.

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

[mlir] Add an overload of parseOptionalAttribute for SymbolRefAttr

Avoids parsing other types of attributes when checking if there is
a SymbolRefAttr.

[Attributor][FIX] Ensure to delete all AAs

Before we might have missed calling the destructor on an abstract
attribute if it was created outside the seeding or update phase.
All AAs are now in the AAMap and we can use it to delete them all.

[AArch64][SVE] Allow to lower WHILEop with constant operands to PTRUE

This allows it to fold WHILEop with constant operand to PTRUE instruction in
the case given range is fitted to predicate format. Also, this change
fixes the unsigned overflow error introduced in D137547 for WHILELO lowering.

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

[flang] Fix crash in name resolution

In an error recovery situation, the name resolution code for a
SELECT TYPE statement must check the presence of an optional
expression before calling GetType() upon it.

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

[NFC][llvm-exegesis] Extract `runBenchmarkConfigurations()` out of `benchmarkMain()`

`benchmarkMain()` is already bigger than it should be,
let's extract the important chunk before making it even larger.

[NFC][llvm-exegesis] `BenchmarkRunner`: split `runConfiguration()` into `getRunnableConfiguration()` + `runConfiguration()`

We can run as many `getRunnableConfiguration()` in parallel as we want,
but `runConfiguration()` must be run *completely* standalone from everything.
This is a step towards enabling threading.

[NFC][llvm-exegesis] `InstructionBenchmark`: only allow move constructor

We don't ever legitimately need to copy it, so let's make that explicit

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

Removing .c_str() has a semantics difference, but the use scenarios
likely do not matter as we don't have NUL in the strings.

[llvm-exegesis] Unbreak `--benchmarks-file=<f>`

I'm absolutely flabbergasted by this.
I was absolutely sure this worked.
But apparently not.

When outputting to the file, we'd write a single `InstructionBenchmark`
to it, and then close the file. And for the next `InstructionBenchmark`,
we'd reopen the file, truncating it in process,
and thus the first `InstructionBenchmark` would be gone...

Remove redundant .c_str() and .get() calls

Reviewed By: MaskRay

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

cmake: Enable 64bit off_t on 32bit glibc systems

Pass -D_FILE_OFFSET_BITS=64 to compiler flags on 32bit glibc based
systems. This will make sure that 64bit versions of LFS functions are
used e.g. seek will behave same as lseek64. Also revert [1] partially
because this added a cmake test to detect lseek64 but then forgot to
pass the needed macro to actual compile, this test was incomplete too
since libc implementations like musl has 64bit off_t by default on 32bit
systems and does not bundle[2] -D_LARGEFILE64_SOURCE under -D_GNU_SOURCE
like glibc, which means the compile now fails on musl because the cmake
check passes but we do not have _LARGEFILE64_SOURCE defined. Using the
*64 function was transitional anyways so use -D_FILE_OFFSET_BITS=64
instead

[1] https://github.com/llvm/llvm-project/commit/8db7e5e4eed4c4e697dc3164f2c9351d8c3e942b
[2] https://git.musl-libc.org/cgit/musl/commit/?id=25e6fee27f4a293728dd15b659170e7b9c7db9bc

Reviewed By: MaskRay

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

[flang] Check constant arguments to bit manipulation intrinsics even if not foldable

When some arguments that specify bit positions, shift counts, and field sizes are
constant at compilation time, but other arguments are not constant, the compiler
should still validate the constant ones.  In the current sources, validation is
only performed for intrinsic references that can be folded to constants.

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

[clang] Convert OptionalFileEntryRefDegradesToFileEntryPtr to std::optional

[llvm][ADT] Allow returning `std::nullopt` in TypeSwitch

Returning `std::nullopt` from the case of a `TypeSwitch` yields broken results, by either falling through to another case, or falling of the switch entirely and hitting an assertion. This is simply due to the use of `operator=` of what is now `std::optional`, which has an overload specifically for `std::nullopt`, causing the internal optional, used for the `TypeSwitch` result to be reset, instead of a value being constructed from the `std::nullopt`.

The fix is to simply use the `emplace` method of `std::optional`, causing a value to always be constructed from the value returned by the case function.

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

Optional: Deprecated value()

https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716/19

value() is a 15.0.0 API for std::optional migration.
std::optional::value() has undesired exception checking semantics and is
unavailable in older Xcode (see
_LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS). Deprecate value() to prevent
new in-tree uses which may accidentally cause build breakage for older
Xcode when contributors perform std::optional migrating.

Some downtream MLIR projects such as tensorflow/mlir-hlo, stablehlo use
value(), so we do not remove it now.

Optional: Avoid value() uses

prerequisite to deprecate the new API value() whose counterpart in
std::optional has undesired exception checking semantics and is
unavailable in older Xcode.

[flang] llvm::Optional::value() => => operator*/operator->

std::optional::value() has undesired exception checking semantics and is
unavailable in older Xcode (see _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS). The
call sites block std::optional migration.

[X86] SandyBridge - fix ADC RMW uop count

These should consistently use the fused domain count, not the unfused domain

Confirmed with Agner + uops.info

[flang] Fixed buildbot failured after D140236.

Removed unused functions searchFunctionInLibrary and getFuncOp.

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

precommit APSInt format for D140059

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

[NFC][CMake] Fix AnalysisTests build after 07af0e2d3e8485ad6f84da1ad9851538b62d2942

The new code uses ModuleInliner, but does not link to the library
that provides it.

[X86] Fix BMI uop/throughputs on znver1/znver2

Most BMI ops are 2uop and 0.5 throughput - interestingly TZCNTrm doesn't take an extra uop but the other instructions do

Confirmed by AMD SoG + Agner

[lldb] llvm::Optional::value() && => operator*/operator->

std::optional::value() has undesired exception checking semantics and is
unavailable in older Xcode (see _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS). The
call sites block std::optional migration.

[NFC][flang] Removed pgmath handling from lowering.

I kept the possibility to use pgmath in constant folding
just in case. We can remove it later, if it is proven to be redundant.

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

[NFCI][llvm-exegesis] `BenchmarkRunner::runConfiguration()`: extract `assembleSnippet()` helper

[NFC][llvm-exegesis] `BenchmarkRunner::runConfiguration()`: deduplicate `DumpObjectToDisk` handling

Always assemble into buffer, that is then optionally dumped into file.

[NFC][llvm-exegesis] `BenchmarkRunner::runConfiguration()`: reformat

[NFCI][llvm-exegesis] Extract 'Min' repetition handling from `BenchmarkRunner` into it's caller

If `BenchmarkRunner::runConfiguration()` deals with more than a single
repetitor, tasking will be less straight-forward to implement.
But i think dealing with that in it's callee is even more readable.

[clang-tools-extra] llvm::Optional::value => operator*/operator->

std::optional::value() has undesired exception checking semantics and is
unavailable in older Xcode (see _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS). The
call sites block std::optional migration.

[clang] llvm::Optional::value() && => operator*/operator->

std::optional::value() has undesired exception checking semantics and is
unavailable in older Xcode (see _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS). The
call sites block std::optional migration.

[mlir] llvm::Optional::value() && => operator*/operator->

std::optional::value() has undesired exception checking semantics and is
unavailable in older Xcode (see _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS). The
call sites block std::optional migration.

[mlir] llvm::Optional::value => operator*/operator->

std::optional::value() has undesired exception checking semantics and is
unavailable in older Xcode (see _LIBCPP_AVAILABILITY_BAD_OPTIONAL_ACCESS). The
call sites block std::optional migration.

[flang] Check for another case of ambiguous generic resolution

When specific procedures of a generic have dummy procedures,
underspecified actual procedures can match more than one specific
procedure.  This can happen with actual procedures that are
externals with implicit interfaces, including the completely
unspecified case of a PROCEDURE() or EXTERNAL that doesn't even
differentiate between a subroutine and a function.

Generic resolution can already handle cases of ambiguous resolution
due to the use of NULL() actual arguments with no MOLD= arguments
to define their types.  Extend the handling of ambiguous actual
arguments to include the case of underspecified actual procedures.

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

Reapply "[InlineAdvisor] Allow loading advisors as plugins"

This reverts commit 8d22a63e2c8b4931113ca9d1ee8b17f7ff453e81.

Fix was missing dependency.

[flang] Check C854, C855, & C856 on PROTECTED entities

Check for things that are not allowed to bear the PROTECTED
attribute.

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

[flang] Apply definability checks in ALLOCATE/DEALLOCATE statements

The pointers and allocatables that appear in ALLOCATE and DEALLOCATE
statements need to be subject to the general definability checks so
that problems with e.g. PROTECTED objects can be caught.

(Also: regularize the capitalization of the DEALLOCATE error messages
while I'm in here so that they're consistent with the messages that
can come out for ALLOCATE.)

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

Fix unused variable warnings in SIFrameLowering.cpp for release build, NFC

Update the bazel's llvm-config.h.cmake file

Reflect the change 7d2c1150d31bb3692c81f6ecb0dbe61170e31212, fix the bazel test
breakage.

[flang] Enforce C1529 as a warning, C919 as an error

Constraint C1529 requires that the base object of a type-bound procedure
reference be a scalar if the TBP has the NOPASS attribute.  Most
compilers do not enforce this constraint and it does not appear to
have any implementation justification, so emit portability warning.

On the other hand, we fail to enforce C919 for references to
procedure pointer components, whose base objects must of course
be scalars in order to avoid ambiguity and empty arrays, whether
NOPASS is present or not.

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

Fix unused variable warning in release build, NFC.

[X86] All the WriteBLS instructions take 2uops, not 1uop

Confirmed by AMD SoG + Agner + uops.info

[AggressiveInstCombine] Fix invalid TypeSize conversion when combining loads.

Much of foldLoadsRecursive relies on knowing the size of loaded
data, which is not possible for scalable vector types.  However,
the logic of combining two small loads into one bigger load does
not apply for vector types so rather than converting the algorithm
to use TypeSize I've simply added an early exit for vectors.

Fixes #59510

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

[flang] Impose DATA initialization size limit to avoid crashing

Impose a large but finite limit on the size of a variable being
initialized in a DATA statement to provide a readable error message
for artificial test cases that's better than a memory allocation
failure crash.

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

[dsymutil] fix accidental 32bit truncation in patchFrameInfoForObject

patchFrameInfoForObject accidentally truncates FDE addresses
to the least significant 32bits, which causes the Go bug: https://github.com/golang/go/issues/25841.

Patch by Alessandro Arzilli

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

Revert "Reland 2nd attempt:  [lld-macho] Fix bug in reading cpuSubType field."

This reverts commit b08acee423935c16a1503335d78b84ccbbae4ef8.
Still breaks tests, see https://reviews.llvm.org/D139572#4003191