[asan] Convert more tests to check 'target=...'

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

[mlir][sparse] avoid unnecessary tmp COO buffer and convert when lowering ConcatentateOp.

When concat along dim 0, and all inputs/outputs are ordered with identity dimension ordering,
the concatenated coordinates will be yield in lexOrder, thus no need to sort.

Reviewed By: aartbik

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

[IR][NFC] Cleanup: Remove non-const block iterators to force all updates go through an interface function

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

[flang] Check for elemental finalizer when defined object has vector subscript

When a defined object is an array with a vector subscript, and it has a
finalizable type, it may have a final subroutine with a matching or
assumed rank dummy argument that cannot be called.  Unless there is
also a suitable elemental final subroutine, diagnose such a case
with an error message.

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

[VPlan] Use macro to define recipe classof implementation (NFC).

Add a VP_CLASSOF_IMPL macro to define common classof implementations for
recipes. This reduces duplication and also adds missing implementations
to existing recipes.

Undo one llvm::Optional => std::optional

Using std::optional in Support/TypeTraitsTest.cpp causes gcc 7.5 to
complain. No public bots run a gcc that old, but we have internal bots
that do.

/home/probinson/projects/llvm-org/llvm-project/llvm/unittests/Support/TypeTraitsTest.cpp: In instantiation of ‘void {anonymous}::triviality::TrivialityTester() [with T = std::optional<int>; bool IsTriviallyCopyConstructible = true; bool IsTriviallyMoveConstructible = true]’:
/home/probinson/projects/llvm-org/llvm-project/llvm/unittests/Support/TypeTraitsTest.cpp:121:52:   required from here
/home/probinson/projects/llvm-org/llvm-project/llvm/unittests/Support/TypeTraitsTest.cpp:29:3: error: static assertion failed: Mismatch in expected trivial copy construction!
   static_assert(llvm::is_trivially_copy_constructible<T>::value ==
   ^~~~~~~~~~~~~
/home/probinson/projects/llvm-org/llvm-project/llvm/unittests/Support/TypeTraitsTest.cpp:32:3: error: static assertion failed: Mismatch in expected trivial move construction!
   static_assert(llvm::is_trivially_move_constructible<T>::value ==
   ^~~~~~~~~~~~~

AArch64: Stop storing MachineFunction in MachineFunctionInfo

The constructor should not depend on the MachineFunction

[NFC] Adjust adjusted manual checklines in DebugInfo to be less sensitive to the Value name

The test was passing for me locally, but fails on bots:
https://lab.llvm.org/buildbot/#/builders/98/builds/29290/steps/10/logs/stdio

[NFC][InstCombine] Add miscompile reproducer from https://reviews.llvm.org/D139275#4001580

SimplifyCFG change is correct and not at fault here.
The actual miscompile appears to be happening in InstCombine.

```
$ /builddirs/llvm-project/build-Clang15/bin/opt -load /repositories/alive2/build-Clang-release/tv/tv.so -load-pass-plugin /repositories/alive2/build-Clang-release/tv/tv.so -passes='tv,instcombine,tv' -o /dev/null /repositories/llvm-project/llvm/test/Transforms/InstCombine/D139275_c4001580.ll

----------------------------------------
define float @D139275_c4001580(float %arg) {
%0:
  %i = fcmp ugt float %arg, 0.000000
  %i1 = fcmp ult float %arg, 1.000000
  %i2 = and i1 %i, %i1
  %i3 = fcmp uge float %arg, 0.100000
  %i4 = xor i1 %i, %i2
  %i5 = select i1 %i4, float 0.100000, float 0.000000
  %i6 = and i1 %i3, %i2
  %i7 = fadd float %arg, -0.100000
  %i8 = select i1 %i6, float %i7, float %i5
  ret float %i8
}
=>
define float @D139275_c4001580(float %arg) {
%0:
  %i = fcmp ugt float %arg, 0.000000
  %i1 = fcmp ult float %arg, 1.000000
  %i2 = and i1 %i, %i1
  %i3 = fcmp uge float %arg, 0.100000
  %i7 = fadd float %arg, -0.100000
  %i5 = select i1 %i3, float %i7, float 0.100000
  %i8 = select i1 %i2, float %i5, float 0.000000
  ret float %i8
}
Transformation doesn't verify! (unsound)
ERROR: Value mismatch

Example:
float %arg = #x3dcbb820 (0.099472284317?)

Source:
i1 %i = #x1 (1)
i1 %i1 = #x1 (1)
i1 %i2 = #x1 (1)
i1 %i3 = #x0 (0)
i1 %i4 = #x0 (0)
float %i5 = #x00000000 (+0.0)
i1 %i6 = #x0 (0)
float %i7 = #xba0a5680 (-0.000527717173?)
float %i8 = #x00000000 (+0.0)

Target:
i1 %i = #x1 (1)
i1 %i1 = #x1 (1)
i1 %i2 = #x1 (1)
i1 %i3 = #x0 (0)
float %i7 = #xba0a5680 (-0.000527717173?)
float %i5 = #x3dcccccd (0.100000001490?)
float %i8 = #x3dcccccd (0.100000001490?)
Source value: #x00000000 (+0.0)
Target value: #x3dcccccd (0.100000001490?)

Pass: (anonymous namespace)::TVPass
Command line: '/builddirs/llvm-project/build-Clang15/bin/opt' '-load' '/repositories/alive2/build-Clang-release/tv/tv.so' '-load-pass-plugin' '/repositories/alive2/build-Clang-release/tv/tv.so' '-passes=tv,instcombine,tv' '-o' '/dev/null' '/repositories/llvm-project/llvm/test/Transforms/InstCombine/D139275_c4001580.ll'

Alive2: Transform doesn't verify!

```

[llvm-profgen] Fix build failure after 5d7950a403bec25e52.

This fixes a build failure with libc++
(`error: no matching function for call to 'max')`

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

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

[flang] Catch bad usage of POINTER attribute

Most attributes apply to only object or only procedure entities,
and attempts to apply them to other kinds of symbol table entries
are caught in name resolution when ConvertToObjectEntity() or
ConvertToProcEntity() fails.  However, the POINTER attribute can
be applied to both, and name resolution can't perform that conversion
yet, and as a result we don't catch many kinds of silly errors.
Fix by ensuring that the symbol is of a type that could eventually
become an object or procedure entity if it is not one already.

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

[gn build] Port 5d7950a403be

[CSSPGO][llvm-profgen] Missing frame inference.

This change introduces a missing frame inferrer aiming at fixing missing frames. It current only handles missing frames due to the compiler tail call elimination (TCE) but could also be extended to supporting other scenarios like frame pointer omission. When a tail called function is sampled, the caller frame will be missing from the call chain because the caller frame is reused for the callee frame. While TCE is beneficial to both perf and reducing stack overflow, a workaround being made in this change aims to find back the missing frames as much as possible.

The idea behind this work is to build a dynamic call graph that consists of only tail call edges constructed from LBR samples and DFS-search for a unique path for a given source frame and target frame on the graph. The unique path will be used to fill in the missing frames between the source and target. Note that only a unique path counts. Multiple paths are treated unreachable since we don't want to overcount for any particular possible path.

A switch --infer-missing-frame is introduced and defaults to be on.

Some testing results:
- 0.4% perf win according to three internal benchmarks.
- About 2/3 of the missing tail call frames can be recovered, according to an internal benchmark.
- 10% more profile generation time.

Reviewed By: wenlei

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

[PowerPC][NFC] Fix typos in PPCISelDAGToDAG

Change:
negtive -> negative
is -> are

Thanks to tschuett for finding these.

[SROA] `isVectorPromotionViable()`: memory intrinsics operate on vectors of bytes (take 3)

* This is a recommit of 3c4d2a03968ccf5889bacffe02d6fa2443b0260f,
* which was reverted in 25f01d593ce296078f57e872778b77d074ae5888,
  because it exposed a miscompile in PPC backend,  which was resolved
  in https://reviews.llvm.org/D140089 / cb3f415cd2019df7d14683842198bc4b7a492bc5.
* which was a recommit of cf624b23bc5d5a6161706d1663def49380ff816a,
* which was reverted in 5cfc22cafe3f2465e0bb324f8daba82ffcabd0df,
  because the cut-off on the number of vector elements was not low enough,
  and it triggered both SDAG SDNode operand number assertions,
  5and caused compile time explosions in some cases.

Let's try with something really *REALLY* conservative first,
just to get somewhere, and try to bump it later.

FIXME: should this respect TTI reg width * num vec regs?

Original commit message:

Now, there's a big caveat here - these bytes
are abstract bytes, not the i8 we have in LLVM,
so strictly speaking this is not exactly legal,
see e.g. https://github.com/AliveToolkit/alive2/issues/860
^ the "bytes" "could" have been a pointer,
and loading it as an integer inserts an implicit ptrtoint.

But at the same time,
InstCombine's `InstCombinerImpl::SimplifyAnyMemTransfer()`
would expand a memtransfer of 1/2/4/8 bytes
into integer-typed load+store,
so this isn't exactly a new problem.

Note that in memory, poison is byte-wise,
so we really can't widen elements,
but SROA seems to be inconsistent here.

Fixes #59116.

Revert "[SimplifyCFG] `FoldBranchToCommonDest()`: deal with mismatched IV's in PHI's in common successor block"

This reverts commit 1bd0b82e508d049efdb07f4f8a342f35818df341, since it leads to
miscompiles. See https://reviews.llvm.org/D139275#3993229 and
https://reviews.llvm.org/D139275#4001580.

Revert "[Driver] Remove Joined -X"

This change is breaking internal builds. We use the -Xfoo pattern but can
now no longer manage whether we allow an unused -Xfoo option to pass as a
warning or promote it to an error.

This reverts commit 98615fd376cea15af21e120e0e3ffa5ba68c2b6d.

Reviewed By: davide

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

[libc++] Install llvm-16-dev explicitly until LLVM16 is stable

The clang-tidy checks can't be properly implemented before LLVM16 because the Clang CMake files don't provide the version before.

Reviewed By: Mordante, #libc

Spies: libcxx-commits, arichardson

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

[TTI] [AArch64] getMemoryOpCost for ptr types

Opaque ptr types have a size in bits of 0. The legalised type is an i64 or
vector of i64s, which do have a size. Because of this difference in size, target
hook getMemoryOpCost modelled stores of ptr types as extending/truncating
load/stores. Now we just check for opaque ptr types and return the legalised
cost. This makes stores of pointers cheaper, and as a result we now SLP
vectorise the changed test case.

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

[MLIR][Linalg] Use `DenseI64ArrayAttr` in `InterchangeOp` (NFC)

Use op separator to improve code navigation.

Reviewed By: hanchung

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

[CostModel][AArch64] Precommit opaque ptr store tests. NFC.

[reg2mem] Add special handling to CatchSwitchInst

When promoting a phi in a catchswitch block to memory, we cannot
insert load/store instruction in that block, and need to insert
them inside all successors instead.

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

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

[InstCombine] Preserve instruction name in replaceInstUsesWith()

Currently InstCombine folds using the
`return replaceInstUsesWith(V, Builder.CreateFoo())`
pattern do not preserve the original name of the instruction.
To preserve the name, you either have to use something like
`return FooInst::Create(...)` which is usually less nice, or go
out of the way to preserve the name with takeName(). We often
don't do that.

This patch instead preserves the name in replaceInstUsesWith()
when replacing a named instruction with an unnamed instruction.
To be conservative, I also added a zero-use check, which is a
proxy for the case where the instruction was just created, rather
than an existing one reused. Possibly we could drop that part.

As InstCombine tests are robust against renames this does not
cause any test diffs, so I regenerated a random test to show the
effects.

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

[PowerPC] Fix up memory ordering after combining BV to a load

The combiner for BUILD_VECTOR that merges consecutive
loads into a wide load had two issues:

- It didn't check that the input loads all have the
  same input chain
- It didn't update nodes that are chained to the original
  loads to be chained to the new load

This caused issues with bootstrap when
3c4d2a03968ccf5889bacffe02d6fa2443b0260f was committed.
This patch fixes the issue so it can unblock this commit.

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

[SCEV] Add SCEV::operands() method (NFC)

Add an operands() method on SCEV, which forwards to the operands()
method of individual SCEV expressions.

[AArch64] Support SLC in ACLE prefetch intrinsics

This change:
- Modifies the ACLE code to allow the new SLC value (3) for the prefetch
  target.

- Introduces a new intrinsic, @llvm.aarch64.prefetch which matches the
  PRFM family instructions much more closely, and can represent all
  values for the PRFM immediate.

  The target-independent @llvm.prefetch intrinsic does not have enough
  information for us to be able to lower to it from the ACLE intrinsics
  correctly.

- Lowers the acle calls to the new intrinsic on aarch64 (the ARM
  lowering is unchanged).

- Implements code generation for the new intrinsic in both SelectionDAG
  and GlobalISel. We specifically choose to continue to support lowering
  the target-independent @llvm.prefetch intrinsic so that other
  frontends can continue to use it.

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

[clang][dataflow] Remove unused lambda capture

Reviewed By: krasimir

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

[AArch64] RASv2 Assembly Support

This feature adds upstream support for FEAT_RASv2 and FEAT_PFAR. Both
are system-register-only, but FEAT_RAS is behind the command-line
extension "+ras", so FEAT_RASv2 is behind "+rasv2".

This patch includes support for ID_AA64MMFR4_EL1. This is an ID system
register so it is not behind any feature flags.

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

[libcxx][Test] Fix expected diagnostics for std types with default integral arguments

The `clang::TypePrinter` has recently been changed to suppress
defaulted integral template parameters in D139986.

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

[SCEV] Return ArrayRef for SCEV operands() (NFC)

Use a consistent type for the operands() methods of different SCEV
types. Also make the API consistent by only providing operands(),
rather than also providin op_begin() and op_end() for some of them.

Use range based loop to iterate over OptTable::PrefixesUnion

And sneak in a small storage optimization of OptTable::PrefixChars

[clang-format] add config parse test for short lambda

Reviewed By: HazardyKnusperkeks, MyDeveloperDay
Differential Revision: https://reviews.llvm.org/D140105

[SCEV] Convert tests to opaque pointers (NFC)

[SCEV] Name instructions in test (NFC)

[libomptarget] Add HSA definitions for memory faults to dynamic_hsa

Summary:
We use the dynamic HSA file to forward declare needed definitions from
the HSA runtime if not present at build time. These definitions were not
included so using them caused problems on systems without it if used.
Just add them.

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

[Alignment] Use Align in SectionRef::getAlignment()

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

[flang] Lower procedure ref to user defined elemental procedures (part 1)

Lower procedure ref to user defined elemental procedure when:
- there are no arguments that may be dynamically optional
- for functions, the result has no length parameters
- the reference can be unordered
- there are not character by value arguments

This uses the recently added hlfir.elemental operation and tools.
The "core" of the argument preparation is shared between elemental
and non elemental calls (genUserCalls is code moved without any
functional changes)

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

[LAA] Convert tests to opaque pointers (NFC)

[clang][DebugInfo] Add DW_AT_default_value support for template template parameters

After this patch, in the following snippet:
```
template <typename T> Foo {};

template <template <typename T> class CT = Foo> Bar {};

Bar<> b;
```

The debug-info entry for the `CT` template parameter will have
a `DW_AT_default_value (true)` attached to it.

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

[llvm][DebugInfo] Add IsDefault parameter to DIBuilder::createTemplateTemplateParameter

This is in preparation for Clang to emit `DW_AT_default_value`
for defaulted template template parameters.

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

[clang][DebugInfo] Simplify logic to determine DW_AT_default_value for template parameters

DWARFv5 added support for labelling template parameters with
DW_AT_default_value to indicate whether the particular instantiation
defaulted parameter. The current implementation only supports a limited
set of possible cases. Namely for non-value-dependent integral template
parameters and simple type template parameters.

Useful cases that don't work are:
1. Type template parameters with defaults that are
   themselves templates. E.g.,
```
template<typename T1, typename T2 = Foo<T1>> class C1;
template<typename T = Foo<int>> class C2;
etc.
```
2. Template template parameters

`clang::isSubstitutedDefaultArgument` already implement the required logic
to determine whether a template argument is defaulted. This patch re-uses
this logic for DWARF CodeGen.

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

[clang][TypePrinter] Teach isSubstitutedDefaultArgument about integral types

This patch handles default integral non-type template parameters.

After this patch the clang TypePrinter will omit default integral
template arguments when the `PrintingPolicy::SuppressDefaultTemplateArgs`
option is specified and sets us up to be able to re-use
`clang::isSubstitutedDefaultArgument` from the DWARF CodeGen
component.

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

[clang][AST][NFC] Expose clang::isSubstitutedDefaultArgument to clang/AST consumers

**Summary**
A use-case has come up in DWARF CodeGen where we want to determine
whether a particular template argument matches the default template
parameter declaration.

Re-using this TypePrinter component there allows us to avoid duplicating
most of this code and immediately allows us to cover a wider range
of use-cases than the DWARF CodeGen does today.

[LAA] Name instructions in test (NFC)

And regenerate test checks.

[AMDGPU] Generate permlane test checks

[ASTContext] Avoid duplicating address space map. NFCI

ASTContext was holding onto a pointer to the Clang->LLVM address space map
which is stored inside TargetInfo. Instead of doing this, we can forward to
TargetInfo instead. This change will allow us to eventually remove
getTargetAddressSpace() from ASTContext and only have this information in
TargetInfo.

Reviewed By: rjmccall

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

[clang] silence unused variable warning

No functional changes intended.

[clang][dataflow] Remove unused argument in getNullability

This change will allow users to call getNullability() without providing an ASTContext.

Reviewed By: gribozavr2

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

[GlobalAA] Convert tests to opaque pointers (NFC)

[LazyCallGraph] Convert tests to opaque pointers (NFC)

[ValueTracking] Convert tests to opaque pointers (NFC)

[TBAA] Convert tests to opaque pointers (NFC)

[LLVM][objcopy] Fix update-section.test on 32 bit platforms

This used %zu to print a uint64_t type. z is for size_t so on 32 bit
we tried to treat it as a 32 bit number.

Use PRIu64 instead to print as 64 bit everywhere.

[MemDep] Convert tests to opaque pointers (NFC)

[MemDep] Run test through instnamer (NFC)

[Lint] Convert tests to opaque pointers (NFC)

[IRSimilarity] Convert tests to opaque pointers (NFC)

[DependenceAnalysis] Convert tests to opaque pointers (NFC)

[clang][ExtractAPI] Fix naming of typedef'd anonymous enums

Anonymous enums that are typedef'd should take on the name of the typedef.

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

[LLVM][objcopy] Update Arm XFAIL in update section test

a1b4e13cff2a792571927ee1fc6eebb05e40fae9 updated this to use
the target= syntax.

However the triple for our Arm bots is usually like:
armv8l-unknown-linux-gnueabihf

With "eabihf" on the end. I assume before we just checked for
"linux-gnu" being in the triple at all but now it is a proper
regex match.

Add .* on the end to account for the ABI tag on the end.

[BasicAA] Convert tests to opaque pointers (NFC)

Revert "[OpenMP][libomptarget] Add AMDGPU NextGen plugin with asynchronous behavior"

This reverts commit 87e6b96b0009983996bfe0aa27d358008c1d1087.

[LoongArch] Add tests showing the optimization pipeline

Other targets like ARM, AArch64, RISCV and X86 have similar tests.

`O1`, `O2` and `O3` appear to be the same for now. But in future, some
passes may be disabled at lower levels (e.g. `O1`). Hoping we can use
FileCheck prefixes for differences to avoid repeating the contents 3
times.

Reviewed By: xen0n, MaskRay

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

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

[LLDB][LoongArch] Add branch instructions for EmulateInstructionLoongArch

Add conditional and unconditional branch instructions for loongarch64.
Note that this does not include floating-point branch instructions, that will come in a later patch.

Reviewed By: SixWeining, DavidSpickett

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

[Delinearization] Convert tests to opaque pointers (NFC)

[Clang] Allow additional mathematical symbols in identifiers.

Implement the proposed UAX Profile
"Mathematical notation profile for default identifiers".

This implements a not-yet approved Unicode for a vetted
UAX31 identifier profile
https://www.unicode.org/L2/L2022/22230-math-profile.pdf

This change mitigates the reported disruption caused
by the implementation of UAX31 in C++ and C2x,
as these mathematical symbols are commonly used in the
scientific community.

Fixes #54732

Reviewed By: tahonermann, #clang-language-wg

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

[RISCV] Pull out repeated calls to getOperand. NFC

Remove else after return.

[Support] llvm::Optional => std::optional

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

[flang] hlfir.apply codegen

Lower hlfir.apply to hlfir.designate in bufferization.

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

[flang] enable as_expr codegen from array without FortranVariabeInterface

The defining op of HLFIR variables is expected to be visible
in most cases, but HLFIR codegen won't rely on it from a correctness
point of view.

This patch allows building a fir.shape from an hlfir::Entity does not
have a visible FortranVariabeInterface defining op.

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

[flang] hlfir.elemental codegen

Without any optimization or when it cannot be optimized before
bufferization, an hlfir.elemental lowers to an array temporary.
Its codegen consists in:
- allocating a temp given the type, shape, and length parameter arguments.
- generating a loop nest given the elemental shape
- inlining the body of the elemental inside the loops, and replacing the
  yield_element by an assignment to an element of the temp.

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

[trace] Change /sys/bus const char * variables to const char []

JSON: llvm::Optional => std::optional

Many files are from language servers.

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

[gn] Port 344230913812cec3b4509c0216cefce06f69dd4d

[SelectionDAG] Port ARC/M68k/LoongArch after D140161

[mlir][llvm] Fastmath flags import from LLVM IR.

This revision adds support to import fastmath flags from LLVMIR. It
implement the import using a listener attached to the builder. The
listener gets notified if an operation is created and then checks if
there are fastmath flags to import from LLVM IR to the MLIR. The
listener based approach allows us to perform the import without changing
the mlirBuilders used to create the imported operations.

An alternative solution, could be to update the builders so that they
return the created operation using FailureOr<Operation*> instead of
LogicalResult. However, this solution implies an LLVM IR instruction
always maps to exatly one MLIR operation. While mostly true, there are
already exceptions to this such as the PHI instruciton. Additionally, an
mlirBuilder based solution also further complicates the builder
implementations, which led to the listener based solution.

Depends on D139405

Reviewed By: ftynse

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

[clang-tidy] Use Python3 for add_new_check.py and rename_check.py

Fixes #58782

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

[clang/Lexer] Enhance `Lexer::getImmediateMacroNameForDiagnostics` to return a result from non-file buffers

Use `SourceManager::isWrittenInScratchSpace()` to specifically check for token paste or stringization, instead of
excluding all non-file buffers. This allows diagnostics to mention macro names that were defined from the command-line.

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

[RISCV] Emit .variant_cc directives for vector function calls.

The patch is splitted from D103435. The patch emits .variant_cc [0] for those
function calls that have vector arguments or vector return values.

[0]: https://github.com/riscv/riscv-elf-psabi-doc/pull/190

Initial authored by: HsiangKai

Reviewed By: reames

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

[docs] Update docs since getBasicBlockList() is now private

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

[NFC] Cleanup: Function::getBasicBlockList() and Function::getSublistAccess() are now private

The Function class now supports an adequate set of member functions to help
modify the BB list, including Function::splice(), Function::erase(),
Function::insert() etc. so we no longer need access to the underlying list.

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

[AA] Allow for flow-sensitive analyses.

All current analyses ignore the context. We make the argument mandatory
for analyses, but optional for the query interface.

Reviewed By: nikic

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

[lld-macho] Don't rewrite -rpath arguments in response file

We only want to rewrite paths to files that the linker looks up. Files
under RPATH are looked up at runtime by dyld.

Reviewed By: #lld-macho, keith

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

[Format] Capture `FormatStyle` by value to avoid use-after-free.

Fixes the test failure in 240e29c5015d246de7fb5e4421aa93042fada59b, reported on the D140058 review thread.

[clang-format][NFC] Turn on some code-changing options one by one

For the code-changing options InsertBraces, RemoveBracesLLVM, and
RemoveSemicolon, turn the option on only when running the token
analyzer pass for it. This improves the run-time and avoids
interference from other options.

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

[OpenMP] Add missing test for pinned memory API

I accidentally left out the test for the pinned API introduced by D138933. Adding it back.

Reviewed By: jdoerfert

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

[AIX][BigArchive][NFC] Add test case that list members of archive with free list in it

The archive is generated via
```
touch foo.c
ar crus libfoo.a foo.c
ar d libfoo.a foo.c
```
Thus it contains free list.

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

AMDGPU/GlobalISel: Do not create readfirstlane with non-s32 type

We should probably handle any 32-bit type here, but the intrinsic
definition and selection pattern currently do not. Avoids a few lit
tests failures when switched on by default.

[flang] Enforce 15.4.2.2(4)(c) - explicit interface required

When a function has an implicit interface its result type may
not have a deferred type parameter.

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

Remove the dependency between lib/DebugInfoDWARF and MC.

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

[mlir][sparse] Added new SparseTensorEncodingAttr::withoutOrdering factory

Reviewed By: aartbik, Peiming

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

[NFC][bazel] Update comment in llvm-config.h.cmake so headers match

[flang] Check for polymorphism in DEALLOCATE statements in pure procedures

Semantic checking for DEALLOCATE statements omitted checks for
polymorphic objects and ultimate allocatable components in a pure
procedure, which if not caught would allow execution of an impure
FINAL subroutine defined on a type extension.

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

[mlir][tosa] Make tosa.resize to linalg avoid redundant loads for unit width

When using a tosa resize for ?x1x1x? to ?x1x?x? we should avoid doing a 2D
interpolation as only two unique values are loaded. As the extract operation
performance numerical computation on its values the superfluous extracts may
fail to be coalesced. Instead we only interpolate between the values if there
are multiple values to interpolate between.

For the integer case we also perform scaling by the scaling-factor to apply
the same integer scaling behavior as interpolation.

Reviewed By: jpienaar, NatashaKnk

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

Implement LWG-3646 std::ranges::view_interface::size returns a signed type

Reviewed By: Mordante, philnik, #libc

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

[mlir][sparse] add dim level type toString convenience method

Reviewed By: wrengr, bixia

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

[clang][deps] Implement `dump()` for the VFS