[NFC] [C++20] [Modules] Refactor Sema::isModuleUnitOfCurrentTU into
Decl::isInCurrentModuleUnit

Refactor `Sema::isModuleUnitOfCurrentTU` to `Decl::isInCurrentModuleUnit`
to make code simpler a little bit. Note that although this patch
introduces a FIXME, this is an existing issue and this patch just tries
to describe it explicitly.

Reland "[PowerPC] Add target feature requirement to builtins"

This relands D143467 after fixing build failure with GCC.

[SimpleLoopUnswitch] unswitch selects

The old LoopUnswitch pass unswitched selects, but the changes were never
ported to the new SimpleLoopUnswitch.

We unswitch by turning:

```
S = select %cond, %a, %b
```

into:

```
head:
br %cond, label %then, label %tail

then:
br label %tail

tail:
S = phi [ %a, %then ], [ %b, %head ]
```

Unswitch selects are always nontrivial, since the successors do not exit
the loop and the loop body always needs to be cloned.

Unswitch selects always need to freeze the conditional if the
conditional could be poison or undef. Selects don't propagate
poison/undef, and branches on poison/undef causes UB.

Reviewed By: nikic, kachkov98, vitalybuka

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

[test] Clean up Driver/check-time-trace*

Rename check-time-trace* to ftime-trace*.
Avoid deprecated %T.

[CombinerHelper] Fix gcc warning [NFC]

Without the fix gcc complains with
 ../lib/CodeGen/GlobalISel/CombinerHelper.cpp:1652:52: warning: suggest parentheses around '&&' within '||' [-Wparentheses]
  1652 |          SrcDef->getOpcode() == TargetOpcode::G_OR && "Unexpected op");
       |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~~

AMDGPU: Add baseline tests for fmed3 shrinking combine

GlobalISel: Fold out G_FPTRUNC(G_FPEXT)

TableGen: Fix missing C++ mode comments

Revert "Revert "[ValutTracking] Use isGuaranteedNotToBePoison in impliesPoison""

This reverts commit 706e8110573c83f140a63b40803d6370c86c1414.

[lli] Honor -mtriple option in -jit-kind=orc mode.

Useful for lli debugging / experiments. See, for example, discussion at
https://reviews.llvm.org/D149996.

[LegalizeTypes] Simplify code for UndefinedBooleanContent in PromoteIntOp_VECREDUCE.

We can treat UndefinedBooleanContent the same as ZeroOrOneBooleanContent.
There's no reason to consider sign extending.

[lli] Improve support for MinGW by implementing __main as a no-op.

Without this function lli will error out on MinGW with a missing symbol error
for __main.

Cygwin and MinGW insert calls from the main function to the runtime function
__main. The __main function is responsible for setting up main's environment
(e.g. running static constructors), however this is not needed when running
under lli: the executor process will have run non-JIT ctors, and ORC will take
care of running JIT'd ctors. To avoid a missing symbol error we just implement
__main as a no-op.

[LegalizeTypes] Use ISD::isTrueWhenEqual to simplify code. NFC

[mlir][Linalg] Avoid collapsing dimensions of linalg op that arent foldable.

The collapsing dimensions transformation is limited to only those
cases where the sequence of dimensions are contiguous in all the
ranges of the indexing maps of the operation. Add this check before
applying the transformation.

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

[X86] Add test cases for fminimum/fmaximum with vector zero operands.

[spirv][math] Fix sign propagation for math.powf conversion

For `x^y`, the result's sign should consider whether `y` is
an integer and whether it's odd or even.

This still does not cover all corner cases regarding `x^y`
but it's an improvement over the current implementation.

Reviewed By: antiagainst, qedawkins

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

fix bot failure https://lab.llvm.org/buildbot/#/builders/38/builds/11709

Some generic cases have empty prologue on some platforms like hexagon,
but non empty prologue on some other platform like PPC.

Remove the checks for the optimized lines hit by D147506.

[docs] [C++20] [Modules] Remove the section 'Source content consistency'

Since the C++20 named modules won't check source files consistency after
5b388f8, it would be better to remove this section in the document.

[RISCV] Make Zvfh depend on Zfhmin.

According to the v spec, the Zvfh extension depends on the Zve32f and Zfhmin extensions.

Reviewed By: craig.topper

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

[NFC][HWASAN] replace redundant calls to IRBuilder::get*Ty() with saved types

Reviewed By: vitalybuka

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

[DebugLine] save one debug line entry for empty prologue

Reland D147506 after fixing the failure in bot
https://lab.llvm.org/buildbot/#/builders/247/builds/4125

Some debuggers like DBX on AIX assume the address in debug line
entries is always incremental. But clang generates two entries (entry
for file scope line and entry for prologue end) with same address if
prologue is empty

And if the prologue is empty, seems the first debug line entry for the
function is unnecessary(i.e. removing the first entry won't impact the
behavior in GDB on Linux), so I implement this for all debuggers.

Reviewed By: dblaikie

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

[DebugInfo] add test case for D147506, NFC

[DebugLine] save one debug line entry for empty prologue

[TableGen] Fix null pointer dereferences in TreePattern::ParseTreePattern()

Bugs were found by Svace static analysis tool. Null pointers are
dereferenced right after error checking that does not return from
function.

Reviewed By: arsenm

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

Revert "[test] [llvm-config] Assume unix style lib names on mingw targets"

This reverts commit 38db3795e706b212a34140a395d642195b9d150e.

This change was causing a test failure on the PS5 Windows bot:
https://lab.llvm.org/buildbot/#/builders/216/builds/20982

Adopt Properties to store operations inherent Attributes in the NVGPU dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

Adopt Properties to store operations inherent Attributes in the MLProgram dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

Adopt Properties to store operations inherent Attributes in the Memref dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

Adopt Properties to store operations inherent Attributes in the Math dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

Adopt Properties to store operations inherent Attributes in the IRDL dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

Adopt Properties to store operations inherent Attributes in the Index dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

[clangd] Fix a build failure. NFC

This is caused by 7385cc389aba.

Re-revert "[ValueTracking] Use knownbits interface for determining if `div`/`rem` are safe to speculate"

Seems to be causing a bug in CorrelatedValuePropegation. Reverting
while the issue is investigated.

This reverts commit 6c667abf3294d61e4fbe1238e1755c79f7547f1b.

[nfc] Remove dead code from ObjectFileMachO

The old way of lldb reading the on-disk shared cache is still in
the sources, but we use dyld SPI to inspect this binary now.  This
code is no longer called.

[Driver][test] Exclude `-o /dev/null` test for Windows

lit changes /dev/null to a special filename, and `"-dumpdir" "/dev/null-"` will fail.

[KCFI] Expand the KCFI term in comments (NFC)

[mlir] Remove unused variable 'kCopyFlag' in OpenACCToLLVMIRTranslation.cpp (NFC)

/data/llvm-project/mlir/lib/Target/LLVMIR/Dialect/OpenACC/OpenACCToLLVMIRTranslation.cpp:41:27: error: unused variable 'kCopyFlag' [-Werror,-Wunused-const-variable]
static constexpr uint64_t kCopyFlag = kDeviceCopyinFlag | kHostCopyoutFlag;
                          ^
1 error generated.

[NFC] Refactor loop metadata movement

* Use 'if (T v = expr)' idiom
* llvm.loop is a fixed metadata ID

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

Reviewed By: kazu

[scudo] Change secondary StatsAllocated update

In the secondary allocation routine, the StatsAllocated stat is
increased by BlockSize. However, in the deallocate routine, the
stat subtract uses CommitSize. CommitSize can be bigger than BlockSize
so this can lead to a negative calculated stat. Since the stats
are not guaranteed to be completely accurate, just add CommitSize
during allocation.

Reviewed By: Chia-hungDuan

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

[mlir][gpu] Reduction ops canonicalizatios

Make group ops uniform if `gpu.launch` is their direct parent.

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

Revert "[mlir][python] Allow specifying block arg locations"

This reverts commit 4d0d295b618edfc937d5bf247f0853df5c70cb96.

This caused a buildbot failure: https://lab.llvm.org/buildbot/#/builders/61/builds/43479

[clang-tidy] [test] Narrow down a special case to MSVC mode

For MinGW targets, size_t isn't a compiler defined type, just like
for unix targets.

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

[clang] [test] Narrow down MSVC specific behaviours from "any windows" to only MSVC/clang-cl

This fixes running tests with a toolchain that defaults to a MinGW
target.

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

[test] [llvm-config] Assume unix style lib names on mingw targets

Assume the MSVC style naming only for "windows-msvc" targets.

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

[mlir][openacc] Cleanup acc.parallel from old data clause operands

Remove old clause operands from acc.parallel operation since
the new dataOperands is now in place.
private, firstprivate and reductions will receive some redesign but are
not part of the new dataOperands.

Reviewed By: razvanlupusoru

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

[gn build] Manually port e9569748de

[Driver] Add -dumpdir and change -gsplit-dwarf .dwo names for linking

When the final phase is linking, Clang currently places `.dwo` files in the
current directory (like the `-c` behavior for multiple inputs).
Strangely, -fdebug-compilation-dir=/-ffile-compilation-dir= is considered, which
is untested.

GCC has a more useful behavior that derives auxiliary filenames from the final
output (-o).
```
gcc -c -g -gsplit-dwarf d/a.c d/b.c      # a.dwo b.dwo
gcc -g -gsplit-dwarf d/a.c d/b.c -o e/x  # e/x-a.dwo e/x-b.dwo
gcc -g -gsplit-dwarf d/a.c d/b.c         # a-a.dwo a-b.dwo
```

Port a useful subset of GCC behaviors that are easy to describe to Clang.

* Add a driver and cc1 option -dumpdir
* When the final phase is link, add a default -dumpdir if not specified by the user
* Forward -dumpdir to -cc1 command lines
* tools::SplitDebugName prefers -dumpdir when constructing the .dwo filename

GCC provides -dumpbase. If we use just one of -dumpdir and -dumpbase,
-dumpbase isn't very useful as it appends a dash.

```
gcc -g -gsplit-dwarf -dumpdir e d/a.c   # ea.dwo
gcc -g -gsplit-dwarf -dumpdir e/ d/a.c  # e/a.dwo
gcc -g -gsplit-dwarf -dumpbase e d/a.c  # e-a.dwo
gcc -g -gsplit-dwarf -dumpbase e/ d/a.c # e/-a.dwo
```

If we specify both `-dumpdir` and `-dumpbase`, we can avoid the influence of the
source filename when there is one input file.
```
gcc -g -gsplit-dwarf -dumpdir f/ -dumpbase x d/a.c        # f/x.dwo
gcc -g -gsplit-dwarf -dumpdir f/ -dumpbase x d/a.c d/b.c  # f/x-a.dwo f/x-b.dwo
```

Given the above examples, I think -dumpbase is not useful.

GCC -save-temps has interesting interaction with -dumpdir as -save-temps
generated files are considered auxiliary files like .dwo files.

For Clang, with this patch, -save-temps and -dumpdir are orthogonal, which is
easier to explain.

```
gcc -g -gsplit-dwarf d/a.c -o e/x -dumpdir f/ -save-temps=obj # e/a.{i,s,o,dwo}
gcc -g -gsplit-dwarf d/a.c -o e/x -save-temps=obj -dumpdir f/ # f/a.{i,s,o,dwo}

clang -g -gsplit-dwarf d/a.c -o e/x -save-temps=obj -dumpdir f/ # e/a.{i,s,o} f/a.dwo
```

Reviewed By: dblaikie

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

[VPlan] Add printing test with fast-math flags.

Add missing test coverage for D150029.

[clang-format] Put a "trailing" space back in a unit test

Put an intentional "trailing" space back in
FormatTestComments.SplitCommentIntroducers. It was removed in
a4c87f8ccacc by mistake.

[ARM] ARMMachObjectWriter::recordRelocation: reduce strength on a condition

Reviewed By: MaskRay, dmgreen

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

[flang][openacc] Fix lowerbound when there is no subscripts

The lowerbound was not correctly normalized to 0 when the bound
are generated for an array without subscripts.

```
integer :: a(11:20)
!$acc enter data create(a)
```

Reviewed By: razvanlupusoru

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

[FuzzMutate] Module size heuristics

IRMutation::mutateModule() currently requires the bitcode size of the module.
To compute the bitcode size, one way is to write the module to a buffer using
BitcodeWriter and calculating the buffer size. This would be fine for a single
mutation, but infeasible for repeated mutations due to the large overhead. It
turns out that the only IR strategy weight calculation method that depends on
the current module size is InstDeleterStrategy, which deletes instructions more
frequently as the module size approaches a given max size. However, there is no
real need for the size to be in bytes of bitcode, so we can use a different
metric. One alternative is to let the size be the number of objects in the
Module, including instructions, basic blocks, globals, and aliases. Although
getting the number of instructions is still O(n), it should have significantly
less overhead than BitcodeWriter. This suggestion would cause a change to the
IRMutator API, since IRMutator::mutateModule() can calculate the Module size
itself.

Reviewed By: Peter

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

[lldb][NFCI] Remove custom dwarf LEB128 types

The LEB128 type defined by the DWARF standard is explicitly a variable-length
encoding of an integer. LLDB had defined `uleb128` and `sleb128` types
to be 32-bit  but in many places in both LLVM and LLDB we treat the maximum
width of LEB128 types to be 64, so let's remove these types and be
consistent.

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

[flang] Added missing type cast for the implied-do index.

The implied-do index value has 'index' type, and it has to be
converted to the original ac-do-variable's data type.

Reviewed By: jeanPerier

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

[flang][hlfir] Allow passing null() to dummy class argument.

PrologEpilogInserter: Fix -Wunused-variable in -DLLVM_ENABLE_ASSERTIONS=off builds

[mlir][openacc] Cleanup acc.data from old data clause operands

Since the new data operand operations have been added in D148389 and
adopted on acc.data in D149673, the old clause operands are no longer
needed.

The LegalizeDataOpForLLVMTranslation will become obsolete when all
operations will be cleaned. For the time being only the appropriate
part are being removed.

processOperands will also receive some updates once all the operands
will be coming from an acc data operand operation.

Reviewed By: razvanlupusoru

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

Further amend 945f6e65be0d20b3446e7c1537c64151de618af4

This addresses the ARM issue found by:
https://lab.llvm.org/buildbot/#/builders/109/builds/63726

(This test wouldn't run for me locally, hence missing it in the last fix.)

Fix test failure from 945f6e65be0d20b3446e7c1537c64151de618af4

It seems we were testing the behavior of the debug messages!

[clang] Prevent creation of new submodules in ASTWriter

Avoid inferring new submodules for headers in ASTWriter's collection of
affecting modulemap files, since we don't want to pick up dependencies
that didn't actually exist during parsing.

rdar://109112624

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

Revert "[flang][openacc] Fix lowerbound when there is no subscripts"

This reverts commit 626aa8518d873c5760cd033fe49b1809c9de3494.

Wrap debug code with the LLVM_DEBUG macro; NFC

While investigating a bug in Clang, I noticed that -Wframe-larger-than
was emitting extra debug information along with the diagnostic. It
turns out that 2e1e2f52f357768186ecfcc5ac53d5fa53d1b094 fixed an issue
with the diagnostic, but accidentally left in some debug code that was
exposed in all builds.

So now we no longer emit things like:
8/4294967304 (0.00%) spills, 4294967296/4294967304 (100.00%) variables
along with the diagnostic

Fix LLVM sphinx build

This addresses the issues found by:
https://lab.llvm.org/buildbot/#/builders/30/builds/34937

[flang][openacc] Fix lowerbound when there is no subscripts

The lowerbound was not correctly normalized to 0 when the bound
are generated for an array without subscripts.

```
integer :: a(11:20)
!$acc enter data create(a)
```

Reviewed By: razvanlupusoru

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

[CodeGen][KCFI] Move cfi-type lowering to TargetLowering

KCFI machine function passes transform indirect calls with a
cfi-type attribute into architecture-specific type checks bundled
together with the calls. Instead of having a separate pass for each
architecture, add a generic machine function pass for KCFI and
move the architecture-specific code that emits the actual check to
TargetLowering. This avoids unnecessary duplication and makes it
easier to add KCFI support to other architectures.

Reviewed By: nickdesaulniers

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

[BOLT][DWARF][NFC] Fixed an assertion check

Spotted this one while working on new DWARF Rewriter. We were using wrong check
in assertion.

Reviewed By: Amir

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

[mlir][openacc] Cleanup acc.exit_data from old data clause operands

Since the new data operand operations have been added in D148389 and
adopted on acc.exit_data in D149601, the old clause operands are no longer
needed.

The LegalizeDataOpForLLVMTranslation will become obsolete when all
operations will be cleaned. For the time being only the appropriate
part are being removed.

processOperands will also receive some updates once all the operands
will be coming from an acc data operand operation.

Reviewed By: jeanPerier

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

[Clang][Sema] Fix comparison of constraint expressions

This diff switches the approach to comparison of constraint expressions
to the new one based on template args substitution.
It continues the effort to fix our handling of out-of-line definitions
of constrained templates.
This is a recommit of 3a54022934.

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

Do not link asan_rtl_x86_64.S for non x86_64 platforms.

Do not link asan_rtl_x86_64.S for non x86_64 platforms.

Prior to this CL asan_rtl_x86_64.S would be always be linked when
building compiler-rt for non x86_64 platforms, this normally isn't an
issue since at that link time is an empty file anyway.

When attempting to link a Aarch64 program with branch protection enabled
with the address sanitizer.

E.g.
```
clang --target=aarch64 \
      -fsanitize=address \
      -mbranch-protection=standard \
      -Wl,-z,force-bti
      -o test \
      test.cc
```

Results in the linking error from the sections generated from the empty
asan_rtl_x86_64.S owed to missing a .note.gnu.property

Also see [[ https://bugs.chromium.org/p/chromium/issues/detail?id=1427165 | https://bugs.chromium.org/p/chromium/issues/detail?id=1427165 ]]

Reviewed By: vitalybuka

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

[M68k] Register MIR Passes with the PassRegistry

In order to use the -stop-before/after infrastructure. Also remove the
creator function for M68kConvertMOVToMOVMPass, which has never been
created.

NFC.

[lldb] Simplify Log::PutString (NFC)

* As no format string is involved, avoid unecessary call into `Printf`
* Eliminate creation of a `std::string` to print a `StringRef`

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

Revert "[AggressiveInstCombine] folding load for constant global patterened arrays and structs by GEP-indices Differential Revision: https://reviews.llvm.org/D146622 Fixes https://github.com/llvm/llvm-project/issues/61615"

This reverts commit 0574a4be879e07b48ba9be8d63eebba49a04dfe8. It causes a compiler crash due to a div by zero.

[AArch64] Remove global constructors from AArch64Disassembler.cpp.

Instead of using SmallVectors of SmallVectors, use a plain array.

Reviewed By: c-rhodes

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

[flang][openacc] Lower self clause on acc update as host clause

Self clause is the same same as the host clause. Lower it
in a simmilar way.

Reviewed By: razvanlupusoru

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

[clang] Fix initializer_list matching failures with modules

Previously, if a class with a defined public virtual destructor is
declared before including <initializer_list> and initializer_list is
provided via a Clang module, then overload resolution would fail for
std::initializer_list. This is because when Clang sees the virtual
destructor, Clang creates an implicit NamespaceDecl for std to
implicitly declare a std::bad_alloc. That NamespaceDecl is not added to
the translation unit's lookup table, so when the module containing
std::initializer_list is imported later, that module's std NamespaceDecl
can't find the previous std NamespaceDecl during redeclaration lookup,
causing overload resolution to fail.

To fix this, implicitly created std NamespaceDecls are now added to the
lookup map. At the same time, their IdentifierNamespace members are
cleared to prevent regular name lookups from finding it.

Fixes 60929

Reviewed By: ChuanqiXu, #clang-language-wg, inclyc

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

[clang][deps] Teach dep directive scanner about _Pragma

While we cannot handle `_Pragma` used inside macros, we can handle
this at the top level, and it some projects use the `_Pragma("once")`
spelling like that, which was causing spurious failures in the scanner.

Limitations
* Cannot handle #define ONCE _Pragma("once"), same issue as using
  @import in a macro -- ideally we should diagnose this in obvious cases
* Our LangOpts are currently fixed, so we are not handling u"" strings
  or R"()" strings that require C11/C++11.

rdar://108629982

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

[lldb] Simplify predicates of find_if in BroadcastManager

We had some custom classes that were used as the predicate for
`std::find_if`. It would be a lot simpler if we used lambdas instead.

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

[OpenMP][libomptarget] Init device when printing device info

This patch fixes the printing of device information. Devices are initialized
before printing its information. Fixes #61392

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

[clang-tidy] Fix bugprone-assert-side-effect to actually give warnings

Some time ago a patch was merged to disable all clang-tidy warnings
from system macros. This led to bugprone-assert-side-effect
silently no longer working, since the warnings came from a system
macro. The problem was not detected because the fake assert functions
were implemented in the same file as the test, instead of being a
system include like it's done in the real world.

Move the assert to a proper system header, and fix the code to
warn at the correct location.

This patch is breakdown from https://reviews.llvm.org/D147081
by PiotrZSL.

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

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

[mlir][python] Allow specifying block arg locations

Currently blocks are always created with UnknownLoc's for their arguments. This
adds an `arg_locs` argument to all block creation APIs, which takes an optional
sequence of locations to use, one per block argument. If no locations are
supplied, the current Location context is used.

Reviewed By: ftynse

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

[flang] Ensure pointer components are always established

Follow up of https://reviews.llvm.org/D149979 for lowering.

In Fortran, it is possible to assign a pointer to another pointer
with an undefined association status.
When using the runtime do to none trivial pointer association, if the
descriptor are garbage, the runtime cannot safely detect that it has
a garbage descriptor, and it cannot safely know the descriptor size
leading to undefined behavior.
Another reason to initialize descriptor of pointers is to record any
non deferred length parameter value.
Hence, although this is not required by Fortran, f18 always initialize
pointers to NULL().
This was already done in lowering for whole pointer object, but not for
pointer components.

This patch uses the related semantics patch that updated
derivedTypeSpe::HasDefaultInitialization to ensure pointer components
of local and global object are always initialized.

It adds tests to ensure that allocation of such derived type uses the
runtime to ensure the storage is initialized, and that structure
constructors are setting the descriptor component to NULL() if no
initial target is given.

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

[mlir][openacc] Cleanup acc.enter_data from old data clause operands

Since the new data operand operations have been added in D148389 and
adopted on acc.enter_data in D148721, the old clause operands are no longer
needed.

The LegalizeDataOpForLLVMTranslation will become obsolete when all
operations will be cleaned. For the time being only the appropriate
part are being removed.

processOperands will also receive some updates once all the operands
will be coming from an acc data operand operation.

Reviewed By: jeanPerier

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

[flang][openacc] Lower if_present clause correctly on acc update

The `if_present` clause is modeled as an attribute on the
acc.update operation. The lowering was not adding correctly the attribute
when the clause was present. This patch update the lowering to add
the attribute when needed.

Reviewed By: razvanlupusoru

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

libclc: clspv: fix fma, add vstore and fix inlining issues

https://reviews.llvm.org/D147773

Patch by Romaric Jodin <rjodin@google.com>

[HIP] Detect HIP for Ubuntu, Mint, Gentoo, etc.

HIP may be installed into /usr or /usr/local on a variety of Linux
operating systems. It may become unwieldy to list them all.

Reviewed by: Siu Chi Chan, Yaxun Liu

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

[NFC][AMDGPU] Add option to test.

[IRGen] Change annotation metadata to support inserting tuple of strings into annotation metadata array.

Annotation metadata supports adding singular annotation strings to annotation block. This patch adds the ability to insert a tuple of strings into the metadata array.

The idea here is that each tuple of strings represents a piece of information that can be all related. It makes it easier to parse through related metadata information given it will be contained in one tuple.
For example in remarks any pass that implements annotation remarks can have different type of remarks and pass additional information for each.

The original behaviour of annotation remarks is preserved here and we can mix tuple annotations and single annotations for the same instruction.

Reviewed By: paquette

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

[AggressiveInstCombine] folding load for constant global patterened arrays and structs by GEP-indices Differential Revision: https://reviews.llvm.org/D146622 Fixes https://github.com/llvm/llvm-project/issues/61615

[VPlan] Address missed suggestions from D149082.

This address 2 comments missed from D149082. It sets inbounds directly
when creating the GEP and fixes the order in the enum.

[mlir][mem2reg] Add mem2reg rewrite pattern.

This revision introduces the ability to invoke mem2reg as a rewrite pattern. This also modified the canonical mem2reg pass to use the rewrite pattern approach.

Depends on D149825

Reviewed By: gysit

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

Adopt Properties to store operations inherent Attributes in the GPU dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

Adopt Properties to store operations inherent Attributes in the EmitC dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

Adopt Properties to store operations inherent Attributes in the DLTI dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

Adopt Properties to store operations inherent Attributes in the ControlFlow dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

Adopt Properties to store operations inherent Attributes in the Complex dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

Adopt Properties to store operations inherent Attributes in the Bufferization dialect

This is part of an on-going migration to adopt Properties inside MLIR.

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

[OpenMP][libomptarget] Improve device info printing in NextGen plugins

This patch improves the device info printing in the NextGen plugins. The device
info properties are composed of keys, values and units (if necessary). These
properties are pushed into a queue by each vendor-specifc plugin, and later,
these properties are printed processed and printed by the common Plugin
Interface. The printing format is common across the different plugins.

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

[libc++] Add assertions for potential OOB reads in std::sort

We introduced an optimization to std::sort in 4eddbf9f10a6. However,
that optimization led to issues where users that were passing invalid
comparators to std::sort could start seeing OOB reads. This led to
the revert of the std::sort optimization from the LLVM 16 release
(see https://llvm.org/D146421).

This patch introduces _LIBCPP_ASSERTs to the places in the algorithm
where we make an assumption that the comparator will be consistent and
hence avoid a bounds check based on that. If the comparator happens not
to be consistent with itself, these are the places where we would
incorrectly go out of bounds. This allows users that enable libc++
assertions to catch such misuse at the cost of basically a bounds
check. For users that do not enable libc++ assertions (which is 99.9%
of users since assertions are off by default), this is basically a
no-op, and in fact the assertion will turn into a __builtin_assume,
making it explicit to the compiler that it can rely on the fact that
we're not going out of bounds.

I think this patch strikes the right balance. Folks that want absolute
performance will get what they want, since it is a precondition for the
comparator to be consistent, so the bounds checks are technically not
mandatory. Folks who want more safety *already* need to be enabling
libc++ assertions to catch other types of bugs (like operator[] OOB),
so this solution should also work for them.

I do think we have a lot of work towards popularizing the use of libc++
assertions and integrating it better so that users don't have to know
about the obscure _LIBCPP_ENABLE_ASSERTIONS macro to enable them, but
that's a separate concern.

rdar://106897934

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

[clangd][NFX][FIX] Fix conflicting symbol name `Expr`

Summary:
This class has a member named `Expr` which conflicts with the clang type
of the same name due to the namespace. If we want to do this we need to
explicitly scope the variable. This was preventing me from building.
This was introduced in https://reviews.llvm.org/D148457

[NFC][AMDGPU] Pre-commit test.

Pre-commit fold-fabs.ll.

[libc++] Provide an assignment operator from pair<U, V> in C++03

This adds an extension to std::pair in C++03 mode where we provide an
assignment operator from a pair<U, V>. Previously, any code trying to
trigger such an assignment operator would have tried using the
`operator=(pair const&)` copy assignment operator, which would then
have tried creating a `pair const&` by using the unconstrained
pair<U, V> constructor.

After this patch, pair will instead go through operator= directly if
its member types are assignable. If they are not assignable, the extension
operator= is disabled with SFINAE and the pair(pair<U, V>) constructor
will be used. Since that constructor is unconstrained, that will either
work or give a hard error.

This should be pretty transparent to users, but this is technically a
behavior change in C++03. Indeed, if a type has both a valid cross-type
assignment operator *and* a valid cross-type constructor, the library
will now prefer the cross-type assignment instead of going through the
cross-type constructor and then using the copy-constructor. Since this
is the mandated behavior in C++11, however, one could argue that any user
broken by that needs to change their code.

The motivation for this change is to allow simplifying the definition
of std::map's value_type, which requires handling assignment to a pair
of references properly. This patch will allow removing complexity from
https://llvm.org/D121485 instead of adding complexity in that patch.

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