- [Libomptarget] Make the references to 'malloc' and 'free' weak.
- [Libomptarget][NFC] Use C++ style attributes instead

…ment (llvm#69405)

When the code is built with -mbackchain, it is possible to retrieve the
caller's frame and return addresses. GCC already can do this, add this
support to Clang as well. Use RISCVTargetLowering and GCC's
s390_return_addr_rtx() as inspiration. Add tests based on what GCC is
emitting.

Use of llvm::Optional was migrated to std::optional. This included a
change in the constructor of ArrayRef.
However, there are still 2 places in the SubtargetEmitter which uses
llvm::None, causing a compile error when emitted.

Specializing for 8-bit integers to ensure values are printed as integers

Fixes llvm#69310

Fix 'Bullet list ends without a blank line; unexpected unindent.

stack-uar.c is flaky (1 in 256 executions) because the random tag
may be zero (llvm#69221).

This patch works around the issue in the same way as deep-recursion.c

(llvm@aa4dfd3),
by falling back to a neighboring object, which must have a different
(non-zero) tag.

This patch also does a minor cleanup of the aforementioned
deep-recursion.c, for consistency with stack-uar.c.

Co-authored-by: Thurston Dang <thurston@google.com>

The user of CodeExtractor should be able to specify that
the aggregate argument should be passed as a pointer in zero address
space.

CodeExtractor is used to generate outlined functions required by OpenMP
runtime. The arguments of the outlined functions for OpenMP GPU code
are in 0 address space. 0 address space does not need to be the default
address space for GPU device. That's why there is a need to allow
the user of CodeExtractor to specify, that the allocated aggregate parameter
is passed as pointer in zero address space.

Document clang support for function pointers and virtual functions with
HIP

…ion (llvm#68628)

When MergeFuncs creates a thunk, it does not modify the function in
place, but creates a new one altogether. If type metadata is not
properly forwarded to this new function, LowerTypeTests will be unable
to put this thunk into the dispatch table.

The fix here is to just forward the type metadata to the newly created
functions.

The current test cases to guard against speculative execution can actually be
safely speculated because the denominator is known to be not 0 or -1, and
isSafeToSpeculativelyExecuteWithOpcode will account for this. This adds some
more test cases and rejigs some existing ones to use an unknown variable
instead.

This makes it a lot easier to make wide ranging changes like I am
about to do in https://llvm.org/D150610.

…ctions (llvm#69407)

This will make it easier to implement new(nothrow) without calling the
throwing version of new when exceptions are disabled. See
https://llvm.org/D150610 for the full discussion.

The MVETRUNC operation can perform the same truncate of two vectors, without
requiring lane inserts/extracts from every vector lane. This moves the concat
i1 lowering to use it for v8i1 and v16i1 result types, trading a bit of extra
stack space for less instructions.

…n to disable memcpy instrumentation (llvm#69240)

Deploying llvm#67766 to a large internal codebase uncovers many bugs (many
are
probably benign but need cleaning up). There are also issues in
high-profile
open-source projects like v8. Add a cl::opt to disable builtin
instrumentation
for -fsanitize=alignment to help large codebase users.

In the long term, this cl::opt option may still be useful to debug
-fsanitize=alignment instrumentation on builtins, so we probably want to
keep it around.

This patch fixes:

  compiler-rt/lib/builtins/int_to_fp_impl.inc:36:10: error: expression
  is not an integer constant expression; folding it to a constant is a
  GNU extension [-Werror,-Wgnu-folding-constant]

This enables reading block sparse from file using libgen! (and soon also
direct IR codegen)

When compiling for Darwin, sigset is not initialized. 

When -Werror,-Wuninitialized-const-reference are enabled we see the
error:
asan_interceptors.cpp:260:38: error: variable 'sigset' is uninitialized
when passed as a const reference argument here
[-Werror,-Wuninitialized-const-reference]

This fixes the error

We can use std::pop_heap first and then retrieve the top priority item
with pop_back_val, saving one line of code.

function, NFC.

InlinerOrder::front was removed by:

  commit d3b95ec
  Author: Kazu Hirata <kazu@google.com>
  Date:   Sun Sep 18 08:49:44 2022 -0700

This patch removes a mention of front.

Example:

dimLevelType = [ "compressed", "compressed" ] to
map = (d0, d1) -> (d0 : compressed, d1 : compressed)

With the legality checks in place it is now safe to do. S_MOV_B64 shall
not be used with wide literals, thus updating the test.

…nder with undef elements. (llvm#69482)

Division/remainder by undef is immediate UB across the entire vector.

This was broken by b71edfa.

…-pypi-publish (llvm#69438)

Skip TrailingAnnotation when looking for TrailingReturnArrow.

Fixes llvm#69234.

…lvm#69510)

Broke https://lab.llvm.org/buildbot/#/builders/181/builds/24470.

Could we build the example/tutorial code in the submit checks? This
breakage wasn't caught at submit time.

…#69495)

Reduce memory usage by only extract unit DIEs when cloning clang
modules. We don't need the full debug info yet at this stage. This
reduces peak memory usage of dsymutil when linking the swift driver by
multiple gigabytes.

rdar://117156180

During flang handling of semantics of OpenACC private/firstprivate/
reduction clauses (including the implicitly private loop IV), a new
scoped symbol was being created. This could lead to ambiguity in the
lowered FIR - aka having multiple fir.declare for the same symbol.
Because lowering of OpenACC does not materialize the meaning of the
private clauses (by actually creating a scoped local symbol), it does
not make sense to create a new symbol in semantics either.

I updated the acc-symbols01.f90 test to reflect this updated approach.
Technically, the test could be removed, but it made sense to keep in
place to highlight this intentional decision.

This patch fixes variable names in the style guide. Specifically, names
in the form xyz_abc are changed to the form xyzAbc

Signed-off-by: Tai Ly <tai.ly@arm.com>

Currently for any wasm target, llvm will make a pass that removes
irreducible control flow. (See
[here](https://llvm.org/doxygen/WebAssemblyFixIrreducibleControlFlow_8cpp.html)).
This can result in O(NumBlocks * NumNestedLoops * NumIrreducibleLoops +
NumLoops * NumLoops) build time, which has resulted in exceedingly long
build times when testing. This PR introduces a hidden flag to skip this
pass, which brings some of our build times down from 30 minutes to ~6
seconds.

…67863)

This patch consists of porting SDISel patterns of SHXADD instructions to
GISel.
Note that `non_imm12`, a predicate that was implemented with `PatLeaf`,
is now turned into a `PatFrag` of `<op>_with_non_imm12` where `op` is
the operator that uses `the non_imm12` operand, as GISel doesn't have
equivalence of `PatLeaf` at this moment.

Summary:

When a PCM file is loaded, it can go wrong in various ways. The current
diagnostic only produces the name of the malformed PCM, not why it is
malformed. Expand the diagnostic to display what went wrong!

There is only one call site for this diagnostic, and it already passes
the error message:


https://github.com/llvm/llvm-project/blob/main/clang/lib/Serialization/ASTReader.cpp#L4763-L4764

Test Plan:

The modified LIT test.

---------

Co-authored-by: Nuri Amari <nuriamari@fb.com>

…vm#69396)

An oversight in https://reviews.llvm.org/D148836 since this is a
different code path.

AVX10 Architecture Specification:
https://cdrdv2.intel.com/v1/dl/getContent/784267
AVX10 Technical Paper: https://cdrdv2.intel.com/v1/dl/getContent/784343
RFC:
https://discourse.llvm.org/t/rfc-design-for-avx10-options-support/73672

…dling (llvm#69095)

- Add in some other linker command line options that the other BSD's handle
- Make use of AddFilePathLibArgs()
- Handle OpenMP

This is needed when we run out of registers.

…tion (llvm#69540)

This makes sure

- GEN MAP dim=2 lvl=4
  (d0, d1) -> (d0 floordiv 2, d1 floordiv 2, d0 mod 2, d1 mod 2)
--
  (d0, d1, d2, d3) -> (d0 * 2 + d2, d1 * 2 + d3)

is indeed encoded as

MAP-REF (dim=2, lvl=4) isperm=0
  d2l = [ d0/2 d1/2 d0%2 d1%2 ]
  ld2 = [ l2+2*l0 l3+2*l1 ]

…lvm#68474)

Current implementation of matchFunnelShift only allows opposite shift
pattern. Refactor it to allow more pattern.

…ions and referenced by non-ALLOC

bbf7b9d accidentally caused a regression that
is fixed by llvm#69425. Add test to prevent regression.

With this patch, all CFRs can be used for register allocation.

PR llvm#67391 improved atomic codegen by handling memory ordering specified
by the `cmpxchg` instruction. An acquire barrier needs to be generated
when memory ordering includes an acquire operation. This PR improves the
codegen further by only handling the failure ordering.

I have run into assertion failures quite often when calling this method
via `DenseElementsAttr::get`, and I think this would help, at the very
least, by printing out the bit width size mismatches, rather than a
plain assertion failure. I included all the other cases in the method
for completeness

The test is meant to execute on the native target and only initializes
the native target. However, it then gets the default target triple
instead of the process (host) triple. This fails in cases where the
native target and the default target are not the same.

The test was added here: https://reviews.llvm.org/D154100

In the future this should probably be autogenerated so it defines
library version.

See: Discussion in #libc
https://discord.com/channels/636084430946959380/636732994891284500/1163979080979460176

llvm#67285)

As the comments of `InvalidateInstructionCache`: Before the JIT can run
a block of code that has been emitted it must invalidate the instruction
cache on some platforms. I think it applies to LoongArch as LoongArch
has a weak memory-model. But I'm not able to write a test to demonstrate
this issue. Perhaps self-modifing code should be wrote?

…8920)

This allows running these quick checks faster than in our Buildkite
pipeline, which has much more latency. This will also avoid blocking the
rest of the testing pipeline in case the generated-files checks are
failing.

…ee (llvm#68109)

std::atomic is implemented with the following (confusing!) hierarchy of
types:

     std::atomic<T> : std::__atomic_base<T> { ... };
     std::__atomic_base<T> {
          std::__cxx_atomic_impl<T> __impl;
     };
     std::__cxx_atomic_impl<T> {
          _Atomic(T) __val;
     };

Inside std::__atomic_base, we implement the is_lock_free() and
is_always_lock_free() functions. However, we used to implement them
inconsistently:
- is_always_lock_free() is based on whether __cxx_atomic_impl<T> is
always lock free (using the builtin), which means that we include any
potential padding added by _Atomic(T) into the determination.
- is_lock_free() was based on whether T is lock free (using the
builtin), which meant that we did not take into account any potential
padding added by _Atomic(T).

It is important to note that the padding added by _Atomic(T) can turn a
type that wouldn't be lock free into a lock free type, for example by
making its size become a power of two.

The inconsistency of how the two functions were implemented could lead
to cases where is_always_lock_free() would return true, but
is_lock_free() would then return false. This is the case for example of
the following type, which is always lock free on arm64 but was
incorrectly reported as !is_lock_free() before this patch:

     struct Foo { float x[3]; };

This patch switches the determination of is_lock_free() to be based on
__cxx_atomic_impl<T> instead to match how we determine
is_always_lock_free().

rdar://115324353

X86 supports this calling convention but I don't find any special
handling, so I think we can just handle it via CC_RISCV.

This should fix llvm#69197.

…llvm#69386)

Fixes llvm#69367

…lvm#67023)

Same as https://reviews.llvm.org/D147089 but for std::nth_element

…d assignment operators

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

Co-authored-by: Louis Dionne <ldionne.2@gmail.com>

Avoids hitting assertions due to unsupported convolution patterns.

See iree-org/iree#15207 (comment)

…7726)

…e binop is a shift. (llvm#69349)

The RHS of a shift can have a different type than the LHS. If there are
undefs in the vector, we need the undef added to the RHS to match the
type of any shift amounts that are also added to the vector.

For now just don't add shifts if their RHS and LHS don't match.

…8336)

Just like what other targets have done.

And this will make DAG mutations like MacroFusion take effect.

If the first operand of ADDI is a frame index, then it won't have data
dependency of predecessor LUI. So it is impossible to do the DAG
mutation in these two instructions.

Currently the PR formatting job only runs clang-format. There isn't a
lot of utility in running it if there aren't any C/C++ changes as there
will be nothing to format. This isn't super noisy currently as the job
doesn't fail if there aren't any C/C++ changes, but it's a bit of a
waste.

In addition, this patch names the code formatting job "Check C++
Formatting" to make it clear that this job only checks C/C++ formatting
rather than Python formatting/other languages.

Recently, support for building the LLVM documentation within Github
actions landed, allowing for easy testing of the docs both pre and post
landing. This patch extends that functionality to clang and adds in
additional support to the docs Github workflow to only build the docs
for the subproject whose documentation has been touched.

This reverts commit fd31112.

There are two different crash reports on llvm@fd31112

…lvm#69556)"

This reverts commit 80b2aac.

I mistakenly assumed this job didn't also do python formatting
(should've grepped for more than just black in the python portion of
this script). Pulling it out for now to get python formatting working
again while the patch is iterated further.

llvm#68572)

…… (llvm#68394)"

The new warnings are now under a separate flag
`-Wthread-safety-reference-return`, which is on by default under
`-Wthread-safety-reference`.

- People can opt out via `-Wthread-safety-reference
-Wnothread-safety-reference-return`.
This reverts commit 859f2d0.

Control flow does not necessary continue past guard intrinsics, so don't
mark them as willreturn.

This fixes the miscompile in the sdiv-guard.ll test.

…m#69314)

replaceValuesPerBlockEntry() only handled simple and coerced load
values, however the load may also be referenced by a select value.

Additionally, I suspect that the previous code might have been incorrect
if a load had an offset, as it always constructed the AvailableValue
from scratch.

Fixes llvm#69301.

)

Fixes llvm#69369.
Fixes clangd/clangd#1700.

The keyword is intended for debugging purpose. It prints a message to
stderr.

This patch is based on code originally written by Adam Nemet, and on the
feedback received by the reviewers in
https://reviews.llvm.org/D157492.

This patch fixes:

  compiler-rt/lib/builtins/cpu_model.c:590:5: error: unannotated
  fall-through between switch labels [-Werror,-Wimplicit-fallthrough]

by adding a missing "break;".

* `dump`, added in llvm#68793
* `!repr`, added in llvm#68716

…lvm#68897)

* `dump`, added in llvm#68793
* `!repr`, added in llvm#68716

The keyword `assert` was missing, so I have added that too.

…d x, c)) with Zicond. (llvm#69563)

It's only beneficial when cond is setcc with integer equality condition
code. For other case, it has same instruction count as the original.

This PR adds `nvvm.stmatrix` Op to NVVM dialect. The Op collectively
store one or more matrices across all threads in a warp to the given
address location in shared memory.

Add tests with argmem variations.

…tor (llvm#69010)

Adds a new `__builtin_vectorelements()` function which returns the
number of elements for a given vector either at compile-time for
fixed-sized vectors, e.g., created via `__attribute__((vector_size(N)))`
or at runtime via a call to `@llvm.vscale.i32()` for scalable vectors,
e.g., SVE or RISCV V.

The new builtin follows a similar path as `sizeof()`, as it essentially
does the same thing but for the number of elements in vector instead of
the number of bytes. This allows us to re-use a lot of the existing
logic to handle types etc.

A small side addition is `Type::isSizelessVectorType()`, which we need
to distinguish between sizeless vectors (SVE, RISCV V) and sizeless
types (WASM).

This is the [corresponding
discussion](https://discourse.llvm.org/t/new-builtin-function-to-get-number-of-lanes-in-simd-vectors/73911).

…s. (llvm#69329)

A recent commit (llvm#69190) broke the bazel builds. Turns out that Bazel
uses symlinks for providing the test files, which the path expansion of
the module loading mechanism did not handle correctly. This PR fixes
that.

It also reorganizes the tests better: It puts all `.mlir` files that are
included by some other test into a common `include` folder. This greatly
simplifies the definition of the dependencies between the different
`.mlir` files in Bazel's `BUILD` file. The commit also adds a comment to
all included files why these aren't tested themselves direclty and uses
the `%{fs-sep}` expansion for paths more consistently. Finally, it
uncomments all but one of the tests excluded in Bazel because they seem
to run now. (The remaining one includes a file that it itself a test, so
it would have to live *in* and *outside* of the `include` folder.)

…lvm#68962)

The _mm_cmpistri instruction can be used to quickly parse identifiers.

With this patch activated, clang pre-processes <iostream> 1.8% faster,
and sqlite3.c amalgametion 1.5% faster, based on time measurements and
number of executed instructions as measured by valgrind.

The introduction of an extra helper function in the regular case has no
impact on performance, see


https://llvm-compile-time-tracker.com/compare.php?from=30240e428f0ec7d4a6d1b84f9f807ce12b46cfd1&to=12bcb016cde4579ca7b75397762098c03eb4f264&stat=instructions:u

---------

Co-authored-by: serge-sans-paille <sguelton@mozilla.com>

…ize tests. (llvm#69329)"

This reverts commit f681225. That
commit changed the organization of the tests of the transform dialect
interpreter but did not take into account some tests that were added in
the meantime.

As described in: ARM-software/acle#257

Patch by : Sander de Smalen<sander.desmalen@arm.com>

Reviewed By: dtemirbulatov

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

…nize tests. (llvm#69329)"

This reverts commit c122b97 but fixes
tests that were added between submitting llvm#69329 for review and landing
it for the first time.

Building helloworld.c currently errors with "undefined symbol:
__llvm_libc_syscall"

See: llvm#67032

…variables"

This reverts commit 3353f7d.

Fixed test bug (unspecified order of arg evaluation)

…fault_mem_order REQUIRES clause

This patch creates the `OmpRewriteMutator` pass that runs at the end of
`RewriteParseTree()`. This pass is intended to make OpenMP-specific mutations
to the PFT after name resolution.

In the case of the `atomic_default_mem_order` clause of the REQUIRES directive,
name resolution results in populating global symbols with information about the
REQUIRES clauses that apply to that scope. The new rewrite pass is then able to
use this information in order to explicitly set the memory order of ATOMIC
constructs for which that is not already specified.

Given that this rewrite happens before semantics checks, the check of the order
in which ATOMIC constructs without explicit memory order and REQUIRES
directives with `atomic_default_mem_order` appear is moved earlier into the
rewrite pass. Otherwise, these problems would not be caught by semantics
checks, since the PFT would be modified by that stage.

This is patch 4/5 of a series splitting D149337 to simplify review.

Depends on D157983.

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

To fix that ticket we only needed to address the V_LSHLREV_B16 case, but
I did it for all insts just in case.

Fixes llvm#66899

Small fix for failing tests after merge of llvm#69010. The tests need
`REQUIRES` to ensure that the correct headers are available. I've also
added a generic x86 build which does not need headers, so there is at
least one run per test.

When the FPU was selected with "+(no)fp(.dp)" extensions in "-march" or
"-mcpu" options, the FPU used for multilib selection was still the
default one for given architecture or CPU.

We already save the information about signedness ourselves.

As described in: ARM-software/acle#257

Patch by : David Sherwood <david.sherwood@arm.com>

Reviewed By: kmclaughlin

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