David Tenty [Mon, 11 Jul 2022 15:36:19 +0000 (11:36 -0400)]
[libc++][NFC] Add MVS guard for locale_mgmt_zos.h
This header need not be included on non-z/OS IBM platforms (and indeed
will add nothing when it is), so add a guard. This let's us remove the
header without things breaking when shipping libc++ for AIX.
Reviewed By: hubert.reinterpretcast, fanbo-meng
Differential Revision: https://reviews.llvm.org/D129493
Sunil Srivastava [Tue, 12 Jul 2022 18:13:11 +0000 (11:13 -0700)]
Change default C dialect for PS5 to gnu17/gnu18.
Differential Revision: https://reviews.llvm.org/D129404
Hans Wennborg [Tue, 12 Jul 2022 15:58:21 +0000 (17:58 +0200)]
Build Windows releases with libxml enabled, to unbreak llvm-mt
Recent CMake versions have started to prefer llvm-mt when using
clang-cl, which doesn't work at all when llvm-mt is built without
libxml which has been the case so far.
See https://github.com/llvm/llvm-project/issues/55817
Differential revision: https://reviews.llvm.org/D129571
Pavel Labath [Tue, 12 Jul 2022 18:05:20 +0000 (20:05 +0200)]
[lldb] Fix TestDataFormatterLibcxxString broken by D129490
We need to check for the error inside the value object to avoid reading
garbage through invalid (target) pointers.
Aaron Ballman [Tue, 12 Jul 2022 18:06:13 +0000 (14:06 -0400)]
Update the status for more C DRs
This mostly finishes the DRs in the 200s. There are a few DRs left
which will require more thought and work to test.
Zequan Wu [Tue, 12 Jul 2022 17:30:49 +0000 (10:30 -0700)]
Reland "[LLDB][NFC] Decouple dwarf location table from DWARFExpression."
This reland
227dffd0b6d78154516ace45f6ed28259c7baa48 and
562c3467a6738aa89203f72fc1d1343e5baadf3c with failed api tests fixed by keeping
function base file addres in DWARFExpressionList.
Mitch Phillips [Tue, 12 Jul 2022 17:48:19 +0000 (10:48 -0700)]
[~NFC] Fix printf() type punning warning in asan_globals.cpp
Yuanfang Chen [Tue, 12 Jul 2022 17:39:16 +0000 (10:39 -0700)]
[coroutine] add nomerge function attribute to `llvm.coro.save`
It is illegal to merge two `llvm.coro.save` calls unless their
`llvm.coro.suspend` users are also merged. Marks it "nomerge" for
the moment.
This reverts D129025.
Alternative to D129025, which affects other token type users like WinEH.
Reviewed By: ChuanqiXu
Differential Revision: https://reviews.llvm.org/D129530
Mark de Wever [Tue, 12 Jul 2022 17:38:28 +0000 (19:38 +0200)]
[libc++] Fixes CI.
Mark de Wever [Tue, 5 Jul 2022 06:20:33 +0000 (08:20 +0200)]
[libc++][format] Adds integral formatter benchmarks.
This is a preparation to look at possible performance improvements.
Reviewed By: #libc, ldionne
Differential Revision: https://reviews.llvm.org/D129421
Mark de Wever [Sun, 10 Jul 2022 12:36:34 +0000 (14:36 +0200)]
[libc++][chrono] Avoid tautological comparisions.
In our implementation the year is always less than or equal to the
class' `max()`. It's unlikely this ever changes since changing the
year's range will be an ABI break. A static_assert is added as a
guard.
This was reported by @philnik.
Reviewed By: ldionne, #libc
Differential Revision: https://reviews.llvm.org/D129442
Aaron Ballman [Tue, 12 Jul 2022 17:02:20 +0000 (13:02 -0400)]
Silence a sphinx diagnostic; NFC
This addresses the failure with:
https://lab.llvm.org/buildbot/#/builders/92/builds/29618
Nico Weber [Tue, 12 Jul 2022 16:36:09 +0000 (12:36 -0400)]
[gn build] (manually) port
dc63ad8878de
LLVM GN Syncbot [Tue, 12 Jul 2022 16:26:51 +0000 (16:26 +0000)]
[gn build] Port
2240d72f15f3
Roy Jacobson [Tue, 5 Jul 2022 22:37:31 +0000 (01:37 +0300)]
[Sema] Add deprecation warnings for some compiler provided __has_* type traits
Some compiler provided type traits like __has_trivial_constructor have been documented
as deprecated for quite some time.
Still, some people apparently still use them, even though mixing them with concepts
and with deleted functions leads to weird results. There's also disagreement about some
edge cases between GCC (which Clang claims to follow) and MSVC.
This patch adds deprecation warnings for the usage of those builtins, except for __has_trivial_destructor
which doesn't have a GCC alternative.
I made the warning on by default, so I had to silence it for some tests but it's not too many.
Some (decade old) history of issues with those builtins:
https://github.com/llvm/llvm-project/issues/18187
https://github.com/llvm/llvm-project/issues/18559
https://github.com/llvm/llvm-project/issues/22161
https://github.com/llvm/llvm-project/issues/33063
The abseil usage of them that triggered me to add this warning:
https://github.com/abseil/abseil-cpp/issues/1201
Weird interaction of those builtins with C++20's conditionally trivial special member functions:
https://gcc.gnu.org/bugzilla/show_bug.cgi?id=106085
Reviewed By: #clang-language-wg, aaron.ballman
Differential Revision: https://reviews.llvm.org/D129170
Nick Desaulniers [Tue, 12 Jul 2022 16:17:15 +0000 (09:17 -0700)]
[X86] initial -mfunction-return=thunk-extern support
Adds support for:
* `-mfunction-return=<value>` command line flag, and
* `__attribute__((function_return("<value>")))` function attribute
Where the supported <value>s are:
* keep (disable)
* thunk-extern (enable)
thunk-extern enables clang to change ret instructions into jmps to an
external symbol named __x86_return_thunk, implemented as a new
MachineFunctionPass named "x86-return-thunks", keyed off the new IR
attribute fn_ret_thunk_extern.
The symbol __x86_return_thunk is expected to be provided by the runtime
the compiled code is linked against and is not defined by the compiler.
Enabling this option alone doesn't provide mitigations without
corresponding definitions of __x86_return_thunk!
This new MachineFunctionPass is very similar to "x86-lvi-ret".
The <value>s "thunk" and "thunk-inline" are currently unsupported. It's
not clear yet that they are necessary: whether the thunk pattern they
would emit is beneficial or used anywhere.
Should the <value>s "thunk" and "thunk-inline" become necessary,
x86-return-thunks could probably be merged into x86-retpoline-thunks
which has pre-existing machinery for emitting thunks (which could be
used to implement the <value> "thunk").
Has been found to build+boot with corresponding Linux
kernel patches. This helps the Linux kernel mitigate RETBLEED.
* CVE-2022-23816
* CVE-2022-28693
* CVE-2022-29901
See also:
* "RETBLEED: Arbitrary Speculative Code Execution with Return
Instructions."
* AMD SECURITY NOTICE AMD-SN-1037: AMD CPU Branch Type Confusion
* TECHNICAL GUIDANCE FOR MITIGATING BRANCH TYPE CONFUSION REVISION 1.0
2022-07-12
* Return Stack Buffer Underflow / Return Stack Buffer Underflow /
CVE-2022-29901, CVE-2022-28693 / INTEL-SA-00702
SystemZ may eventually want to support "thunk-extern" and "thunk"; both
options are used by the Linux kernel's CONFIG_EXPOLINE.
This functionality has been available in GCC since the 8.1 release, and
was backported to the 7.3 release.
Many thanks for folks that provided discrete review off list due to the
embargoed nature of this hardware vulnerability. Many Bothans died to
bring us this information.
Link: https://www.youtube.com/watch?v=IF6HbCKQHK8
Link: https://github.com/llvm/llvm-project/issues/54404
Link: https://gcc.gnu.org/legacy-ml/gcc-patches/2018-01/msg01197.html
Link: https://www.intel.com/content/www/us/en/developer/articles/technical/software-security-guidance/advisory-guidance/return-stack-buffer-underflow.html
Link: https://arstechnica.com/information-technology/2022/07/intel-and-amd-cpus-vulnerable-to-a-new-speculative-execution-attack/?comments=1
Link: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=ce114c866860aa9eae3f50974efc68241186ba60
Link: https://www.intel.com/content/www/us/en/security-center/advisory/intel-sa-00702.html
Link: https://www.intel.com/content/www/us/en/security-center/advisory/intel-sa-00707.html
Reviewed By: aaron.ballman, craig.topper
Differential Revision: https://reviews.llvm.org/D129572
Chuanqi Xu [Fri, 8 Jul 2022 06:20:50 +0000 (14:20 +0800)]
[AST] [Modules] Handle full cases of DefaultArgStorage::setInherited
There were two assertions in DefaultArgStorage::setInherited previously.
It requires the DefaultArgument is either empty or an argument value. It
would crash if it has a pointer refers to the previous declaration or
contains a chain to the previous declaration.
But there are edge cases could hit them actually. One is
InheritDefaultArguments.cppm that I found recently. Another one is pr31469.cpp,
which was created fives years ago.
This patch tries to fix the two failures by handling full cases in
DefaultArgStorage::setInherited.
This is guaranteed to not introduce any breaking change since it lives
in the path we wouldn't touch before. And the added assertions for
sameness should keep the correctness.
Reviewed By: v.g.vassilev
Differential Revision: https://reviews.llvm.org/D128974
Mariusz Borsa [Mon, 11 Jul 2022 17:14:06 +0000 (10:14 -0700)]
[Sanitizers][Darwin] Remove SANITIZER_MAC
This is to finish the change started by D125816 , D126263 and D126577 (replace SANITIZER_MAC by SANITIZER_APPLE).
Dropping definition of SANITIZER_MAC completely, to remove any possible confusion.
Differential Revision: https://reviews.llvm.org/D129502
Chuanqi Xu [Tue, 12 Jul 2022 15:47:37 +0000 (23:47 +0800)]
[AST] Accept identical TypeConstraint referring to other template
parameters.
The current implementation to judge the similarity of TypeConstraint in
ASTContext::isSameTemplateParameter is problematic, it couldn't handle
the following case:
```C++
template <__integer_like _Tp, C<_Tp> Sentinel>
constexpr _Tp operator()(_Tp &&__t, Sentinel &&last) const {
return __t;
}
```
When we see 2 such declarations from different modules, we would judge
their similarity by `ASTContext::isSame*` methods. But problems come for
the TypeConstraint. Originally, we would profile each argument one by
one. But it is not right. Since the profiling result of `_Tp` would
refer to two different template type declarations. So it would get
different results. It is right since the `_Tp` in different modules
refers to different declarations indeed. So the same declaration in
different modules would meet incorrect our-checking results.
It is not the thing we want. We want to know if the TypeConstraint have
the same expression.
Reviewer: vsapsai, ilya-biryukov
Differential Revision: https://reviews.llvm.org/D129068
Jay Foad [Tue, 12 Jul 2022 10:16:15 +0000 (11:16 +0100)]
[AMDGPU] SILowerControlFlow uses LiveIntervals
The availability of LiveIntervals affects kill flags in the output, so
declare the use to avoid strange effects where the output of this pass
is different depending on what other passes are scheduled after it.
Differential Revision: https://reviews.llvm.org/D129555
Joseph Huber [Tue, 12 Jul 2022 15:40:38 +0000 (11:40 -0400)]
[LinkerWrapper] Clean-up unused definitions
Summary:
There are a few definitions that are unused or unnecessary after
previous changes, clean them up.
Joseph Huber [Tue, 12 Jul 2022 14:10:54 +0000 (10:10 -0400)]
[LinkerWrapper] Make ThinLTO work inside the linker wrapper
Summary:
Previous assumptions held that the LTO stage would only have a single
output. This is incorrect when using thinLTO which outputs multiple
files. Additionally there were some bugs with how we hanlded input that
cause problems when performing thinLTO. This patch addresses these
issues.
The performance of Thin-LTO is currently pretty bad. But I am content to
leave it that way as long as it compiles.
Chuanqi Xu [Tue, 12 Jul 2022 15:19:19 +0000 (23:19 +0800)]
[Modules] Add ODR Check for concepts
Closing https://github.com/llvm/llvm-project/issues/56310
Previously we don't check the contents of concept so it might merge
inconsistent results.
Important Note: this patch might break existing code but the behavior
might be right.
Reviewed By: erichkeane
Differential Revision: https://reviews.llvm.org/D129104
Kai Nacke [Mon, 11 Jul 2022 18:32:42 +0000 (14:32 -0400)]
[GISel] Check useLoadStackGuardNode() before generating LOAD_STACK_GUARD
When lowering llvm::stackprotect intrinsic, the SDAG implementation
checks useLoadStackGuardNode() to either create a LOAD_STACK_GUARD or use
the first argument of the intrinsic. This check is not present in the
IRTranslator, which results in always generating a LOAD_STACK_GUARD even
if the target does not support it.
Reviewed By: arsenm
Differential Revision: https://reviews.llvm.org/D129505
Slava Zakharin [Fri, 8 Jul 2022 22:10:33 +0000 (15:10 -0700)]
[flang] Lower TRANSPOSE without using runtime.
Calling runtime TRANSPOSE requires a temporary array for the result,
and, sometimes, a temporary array for the argument. Lowering it inline
should provide faster code.
I added -opt-transpose control just for debugging purposes temporary.
I am going to make driver changes that will disable inline lowering
for -O0. For the time being I would like to enable it by default
to expose the code to more tests.
Differential Revision: https://reviews.llvm.org/D129497
Krzysztof Drewniak [Thu, 7 Jul 2022 17:32:06 +0000 (17:32 +0000)]
[mlir] Remove VectorToROCDL
Between issues such as
https://github.com/llvm/llvm-project/issues/56323, the fact that this
lowering (unlike the code in amdgpu-to-rocdl) does not correctly set
up bounds checks (and thus will cause page faults on reads that might
need to be padded instead), and that fixing these problems would,
essentially, involve replicating amdgpu-to-rocdl, remove
--vector-to-rocdl for being broken. In addition, the lowering does not
support many aspects of transfer_{read,write}, like supervectors, and
may not work correctly in their presence.
We (the MLIR-based convolution generator at AMD) do not use this
conversion pass, nor are we aware of any other clients.
Migration strategies:
- Use VectorToLLVM
- If buffer ops are particularly needed in your application, use
amdgpu.raw_buffer_{load,store}
A VectorToAMDGPU pass may be introduced in the future.
Reviewed By: ThomasRaoux
Differential Revision: https://reviews.llvm.org/D129308
Ben Langmuir [Fri, 8 Jul 2022 22:51:15 +0000 (15:51 -0700)]
[clang][deps] Override dependency and serialized diag files for modules
When building modules, override secondary outputs (dependency file,
dependency targets, serialized diagnostic file) in addition to the pcm
file path. This avoids inheriting per-TU command-line options that
cause non-determinism in the results (non-deterministic command-line for
the module build, non-determinism in which TU's .diag and .d files will
contain the module outputs). In clang-scan-deps we infer whether to
generate dependency or serialized diagnostic files based on an original
command-line. In a real build system this should be modeled explicitly.
Differential Revision: https://reviews.llvm.org/D129389
Paul Robinson [Tue, 12 Jul 2022 15:09:29 +0000 (08:09 -0700)]
[PS4/PS5] NFC: Use preferred predicate in a triple check
Also add a test to verify this difference in the PS4/PS5 ABIs,
now that we have identified it.
Nico Weber [Tue, 12 Jul 2022 15:08:27 +0000 (11:08 -0400)]
try to fix lldb build after
d489268392d23
Alex Zinenko [Fri, 8 Jul 2022 15:46:10 +0000 (15:46 +0000)]
[mlir] fold more eagerly in structured op splitting
Existing implementation of structured op splitting creates several
affine.apply and affine.min operations in its subshape computation.
As these shapes are further used in data slice extraction, this may lead
to slice shapes being dynamic even when the original shapes and the
splitting point are static. This is particularly visible when splitting
is combined with further subsetting transformations such as tiling. Use
composition and folding more aggressively in splitting to avoid this.
In particular, introduce a `createComposedAffineMin` function that the
affine map used in "min" with the maps used by any `affine.apply` that
may be feeding the operands to the "min". This enables production of
more static shapes. Also introduce a `createComposedFoldedAffineApply`
function that combines the existing `createComposedAffineApply` with
in-place folding to propagate constants produced by zero-input affine
maps. Using these when splitting allows the subsequent canonicalizer
pass to recover static shapes for structured ops.
Reviewed By: nicolasvasilache
Differential Revision: https://reviews.llvm.org/D129379
Nico Weber [Wed, 6 Jul 2022 20:43:48 +0000 (22:43 +0200)]
[clang/mac] Make -mmacos-version-min the canonical spelling over -mmacosx-version-min
This was promised 5 years ago in https://reviews.llvm.org/D32796,
let's do it.
Both flags are still accepted. No behavior change except for which
form shows up in --help output and in dumps of internal state
(such as with RC_DEBUG_OPTIONS).
Differential Revision: https://reviews.llvm.org/D129226
Igor Kudrin [Tue, 12 Jul 2022 14:58:13 +0000 (07:58 -0700)]
[NVPTX] Add missing pass names
Differential Revision:
Thomas Raoux [Tue, 12 Jul 2022 02:31:30 +0000 (02:31 +0000)]
[mlir][vector] Add accumulator operand to MultiDimReduce op
This allows vectorizing linalg reductions without changing the operation
order. Therefore this produce a valid vectorization even if operations
are not associative.
Differential Revision: https://reviews.llvm.org/D129535
David Sherwood [Tue, 21 Jun 2022 13:07:49 +0000 (14:07 +0100)]
[LoopVectorize] Change PredicatedBBsAfterVectorization to be per VF
When calculating the cost of Instruction::Br in getInstructionCost
we query PredicatedBBsAfterVectorization to see if there is a
scalar predicated block. However, this meant that the decisions
being made for a given fixed-width VF were affecting the cost for a
scalable VF. As a result we were returning InstructionCost::Invalid
pointlessly for a scalable VF that should have a low cost. I
encountered this for some loops when enabling tail-folding for
scalable VFs.
Test added here:
Transforms/LoopVectorize/AArch64/sve-tail-folding-cost.ll
Differential Revision: https://reviews.llvm.org/D128272
Simon Pilgrim [Tue, 12 Jul 2022 13:08:47 +0000 (14:08 +0100)]
[DAG] SimplifyDemandedBits - AND/OR/XOR - attempt basic knownbits simplifications before calling SimplifyMultipleUseDemandedBits
Noticed while investigating the SystemZ regressions in D77804, prefer handling the knownbits analysis/simplification in the bitop nodes directly before falling back to SimplifyMultipleUseDemandedBits
Dawid Jurczak [Tue, 12 Jul 2022 13:00:27 +0000 (15:00 +0200)]
[NFC] Fix compile time regression seen on some benchmarks after
a630ea3003 commit
The goal of this change is fixing most of compile time slowdown seen after
a630ea3003 commit on lencod and sqlite3 benchmarks.
There are 3 improvements included in this patch:
1. In getNumOperands when possible get value directly from SmallNumOps.
2. Inline getLargePtr by moving its definition to header.
3. In TBAAStructTypeNode::getField get all operands once instead taking operands in loop one after one.
Differential Revision: https://reviews.llvm.org/D129468
Alex Zinenko [Fri, 8 Jul 2022 11:49:47 +0000 (13:49 +0200)]
[mlir] Handle linalg.index correctly in TilingInterface
The existing implementation of the TilingInterface for Linalg ops was not
modifying the `linalg.index` ops contained within other Linalg ops (they need
to be summed up with the values of respective tile loop induction variables),
which led to the interface-based tiling being incorrect for any Linalg op with
index semantics.
In the process, fix the function performing the index offsetting to use the
pattern rewriter API instead of RAUW as it is being called from patterns and
may mess up the internal state of the rewriter. Also rename the function to
clearly catch all uses.
Depends On D129365
Reviewed By: mravishankar
Differential Revision: https://reviews.llvm.org/D129366
Alex Zinenko [Fri, 8 Jul 2022 11:49:27 +0000 (13:49 +0200)]
[mlir] Use semantically readable functions for transform op effects
A recent commit introduced helper functions with semantically meaningful names
to populate the lists of memory effects in transform ops, use them whenever
possible.
Depends On D129287
Reviewed By: springerm
Differential Revision: https://reviews.llvm.org/D129365
Alex Zinenko [Thu, 7 Jul 2022 13:56:06 +0000 (15:56 +0200)]
[mlir] Transform op for multitile size generation
Introduce a structured transform op that emits IR computing the multi-tile
sizes with requested parameters (target size and divisor) for the given
structured op. The sizes may fold to arithmetic constant operations when the
shape is constant. These operations may then be used to call the existing
tiling transformation with a single non-zero dynamic size (i.e. perform
strip-mining) for each of the dimensions separately, thus achieving multi-size
tiling with optional loop interchange. A separate test exercises the entire
script.
Depends On D129217
Reviewed By: nicolasvasilache
Differential Revision: https://reviews.llvm.org/D129287
Corentin Jabot [Fri, 17 Jun 2022 14:23:41 +0000 (16:23 +0200)]
[Clang] Add a warning on invalid UTF-8 in comments.
Introduce an off-by default `-Winvalid-utf8` warning
that detects invalid UTF-8 code units sequences in comments.
Invalid UTF-8 in other places is already diagnosed,
as that cannot appear in identifiers and other grammar constructs.
The warning is off by default as its likely to be somewhat disruptive
otherwise.
This warning allows clang to conform to the yet-to be approved WG21
"P2295R5 Support for UTF-8 as a portable source file encoding"
paper.
Reviewed By: aaron.ballman, #clang-language-wg
Differential Revision: https://reviews.llvm.org/D128059
Alex Zinenko [Thu, 7 Jul 2022 13:55:44 +0000 (15:55 +0200)]
[mlir] Allow Tile transform op to take dynamic sizes
Extend the definition of the Tile structured transform op to enable it
accepting handles to operations that produce tile sizes at runtime. This is
useful by itself and prepares for more advanced tiling strategies. Note that
the changes are relevant only to the transform dialect, the tiling
transformation itself already supports dynamic sizes.
Depends On D129216
Reviewed By: nicolasvasilache
Differential Revision: https://reviews.llvm.org/D129217
Muhammad Omair Javaid [Tue, 12 Jul 2022 11:56:28 +0000 (16:56 +0500)]
[LLDB] Catagory decorator for watchpoint test in TestCompletion.py
This patch adds watchpoint catagory decorator to watchpoint dependent
tests in TestCompletion.py.
Joseph Huber [Tue, 12 Jul 2022 02:20:29 +0000 (22:20 -0400)]
[OpenMP] Do not link static library with `-nogpulib`
Normally we do not link the device libraries if the user passed
`nogpulib` we do this for the standard bitcode library. This behaviour
was not added when using the static library for LTO, causing it to
always be linked in. This patch fixes that.
Reviewed By: JonChesterfield
Differential Revision: https://reviews.llvm.org/D129534
Joseph Huber [Tue, 12 Jul 2022 12:02:17 +0000 (08:02 -0400)]
[Libomptarget] Allow static assert to work on 32-bit systems
Summary:
We use a static assert to make sure that someone doesn't change the size
of an argument struct without properly updating all the other logic.
This originally only checked the size on a 64-bit system with 8-byte
pointers, causing builds on 32-bit systems to fail. This patch allows
either pointer size to work.
Fixes #56486
Peixin Qiao [Tue, 12 Jul 2022 11:54:24 +0000 (19:54 +0800)]
[NFC][flang][OpenMP] Add comment for handling the data race problem in copyin clause
The reference and description is missed before.
Reviewed By: kiranchandramohan
Differential Revision: https://reviews.llvm.org/D129437
Muhammad Omair Javaid [Tue, 12 Jul 2022 11:24:08 +0000 (16:24 +0500)]
[LLDB] Fix NativePDB/local-variables.cpp for AArch64/Windows
This patch fixes NativePDB/local-variables.cpp test for AArch64 Windows.
There are two changes:
1) Replace function breakpoint with line breakpoint required due to pr56288
2) Adjust "target modules dump ast" test as the output was slightly different
on AArch64/Windows.
Nikita Popov [Tue, 12 Jul 2022 10:38:52 +0000 (12:38 +0200)]
[Mem2Reg] Consistently preserve nonnull assume for uninit load
When performing a !nonnull load from uninitialized memory, we
should preserve the nonnull assume just like in all other cases.
We already do this correctly in the generic mem2reg code, but
don't handle this case when using the optimized single-block
implementation.
Make sure that the optimized implementation exhibits the same
behavior as the generic implementation.
Aaron Ballman [Tue, 12 Jul 2022 10:48:31 +0000 (06:48 -0400)]
Undeprecate ATOMIC_FLAG_INIT in C++
C++20 deprecated ATOMIC_FLAG_INIT thinking it was deprecated in C when it
wasn't. It is expected to be undeprecated in C++23 as part of LWG3659
(https://wg21.link/LWG3659), which is currently Tentatively Ready.
This handles the case where the user includes <stdatomic.h> in C++ code in a
freestanding compile mode. The corollary libc++ changes are in
1544d1f9fdb115782202d72ad200c3f93b2c4f5a.
Nikita Popov [Tue, 12 Jul 2022 10:31:31 +0000 (12:31 +0200)]
[Mem2Reg] Add test for uninitialized nonnull loads (NFC)
This shows a difference in behavior between the single block and
the multi block case.
Vignesh Balasubramanian [Tue, 12 Jul 2022 10:18:51 +0000 (15:48 +0530)]
Fixing build bot failure due to python-pip unavailability.
commit:
51d3f421f48f7c888c37a13be049a4ca8b61436e
failed due to missing python-pip om machine.
Now the ompd gdb-plugin code will be skipped with a warning
if pip is not available in the machine.
David M. Lary [Tue, 12 Jul 2022 09:51:33 +0000 (11:51 +0200)]
[lldb] add SBSection.alignment to python bindings
This commit adds SBSection.GetAlignment(), and SBSection.alignment as a python property to lldb.
Reviewed By: clayborg, JDevlieghere, labath
Differential Revision: https://reviews.llvm.org/D128069
Pavel Labath [Tue, 12 Jul 2022 10:17:29 +0000 (12:17 +0200)]
Revert "[lldb] add SBSection.alignment to python bindings"
The patch didn't get proper attribution. Will recommit.
This reverts commit
4135abca897d1b945193f767cbf42a200b55bbdc.
Pavel Labath [Tue, 12 Jul 2022 09:51:33 +0000 (11:51 +0200)]
[lldb] add SBSection.alignment to python bindings
This commit adds SBSection.GetAlignment(), and SBSection.alignment as a python property to lldb.
Reviewed By: clayborg, JDevlieghere, labath
Differential Revision: https://reviews.llvm.org/D128069
David Green [Tue, 12 Jul 2022 10:03:40 +0000 (11:03 +0100)]
[AArch64] Fix subtarget features for tests. NFC
These tests were using instructions that require feature predicates that
were not enabled.
LLVM GN Syncbot [Tue, 12 Jul 2022 09:49:13 +0000 (09:49 +0000)]
[gn build] Port
73ebcabff2d9
Konstantin Varlamov [Tue, 12 Jul 2022 09:48:29 +0000 (02:48 -0700)]
[libc++][ranges][NFC] Implement the repetitive parts of the remaining range algorithms:
- create the headers (but not include them from `<algorithm>`);
- define the niebloid and its member functions with the right signatures
(as no-ops);
- make sure all the right headers are included that are required by each
algorithm's signature;
- update `CMakeLists.txt` and the module map;
- create the test files with the appropriate synopses.
The synopsis in `<algorithm>` is deliberately not updated because that
could be taken as a readiness signal. The new headers aren't included
from `<algorithm>` for the same reason.
Differential Revision: https://reviews.llvm.org/D129549
Nikita Popov [Tue, 12 Jul 2022 09:20:49 +0000 (11:20 +0200)]
[InlineAsm] Improve error messages for invalid constraint strings
InlineAsm constraint string verification can fail for many reasons,
but used to always print a generic "invalid type for inline asm
constraint string" message -- which is especially confusing if
the actual error is unrelated to the type, e.g. a failure to parse
the constraint string.
Change the verify API to return an Error with a more specific
error message, and print that in the IR parser.
Michael Buch [Fri, 8 Jul 2022 12:19:27 +0000 (13:19 +0100)]
[LLDB][ClangExpression] Remove unused StructVars::m_object_pointer_type
This member variable was removed a while ago in
443427357f539f5ac97e664a53aa9e50788abce9. It was previously used in
materialization code paths that have since been removed. Nowadays,
`m_object_pointer_type` gets set but not used anywhere.
This patch simply removes all remaining instances of it and any
supporting code.
**Testing**
* API tests pass
Differential Revision: https://reviews.llvm.org/D129367
Alex Zinenko [Tue, 12 Jul 2022 09:17:36 +0000 (09:17 +0000)]
[mlir] assorted fixes in transform dialect documentation
Various typos and formatting fixes that make the generated documentation
hard to follow.
Michael Buch [Fri, 8 Jul 2022 09:47:04 +0000 (10:47 +0100)]
[LLDB][DataFormatter] Add data formatter for libcxx std::unordered_map iterator
This patch adds a formatter for libcxx's `std::unordered_map` iterators.
The implementation follows a similar appraoch to the `std::map` iterator
formatter. I was hesistant about coupling the two into a common
implementation since the libcxx layouts might change for one of the
the containers but not the other.
All `std::unordered_map` iterators are covered with this patch:
1. const/non-const key/value iterators
2. const/non-const bucket iterators
Note that, we currently don't have a formatter for `std::unordered_map`.
This patch doesn't change that, we merely add support for its iterators,
because that's what Xcode users requested. One can still see contents
of `std::unordered_map`, whereas with iterators it's less ergonomic.
**Testing**
* Added API test
Differential Revision: https://reviews.llvm.org/D129364
Vignesh Balasubramanian [Tue, 12 Jul 2022 08:32:50 +0000 (14:02 +0530)]
[OpenMP][OMPD] GDB plugin code to leverage libompd to provide debugging
support for OpenMP programs.
This is 5th of 6 patches started from https://reviews.llvm.org/D100181
This plugin code, when loaded in gdb, adds a few commands like
ompd icv, ompd bt, ompd parallel.
These commands create an interface for GDB to read the OpenMP
runtime through libompd.
Reviewed By: @dreachem
Differential Revision: https://reviews.llvm.org/D100185
Alex Zinenko [Thu, 7 Jul 2022 13:55:23 +0000 (15:55 +0200)]
[mlir] Add ReplicateOp to the Transform dialect
This handle manipulation operation allows one to define a new handle that is
associated with a the same payload IR operations N times, where N can be driven
by the size of payload IR operation list associated with another handle. This
can be seen as a sort of broadcast that can be used to ensure the lists
associated with two handles have equal numbers of payload IR ops as expected by
many pairwise transform operations.
Introduce an additional "expensive" check that guards against consuming a
handle that is assocaited with the same payload IR operation more than once as
this is likely to lead to double-free or other undesired effects.
Depends On D129110
Reviewed By: nicolasvasilache
Differential Revision: https://reviews.llvm.org/D129216
Konstantin Varlamov [Tue, 12 Jul 2022 09:06:22 +0000 (02:06 -0700)]
[libc++][ranges][NFC] Consolidate some repetitive range algorithm tests:
- checking that the algorithm supports predicates returning
a non-boolean type that's implicitly convertible to `bool`;
- checking that predicates and/or projections are invoked using
`std::invoke`.
Differential Revision: https://reviews.llvm.org/D129414
Jay Foad [Wed, 6 Jul 2022 13:00:32 +0000 (14:00 +0100)]
[MachineVerifier] Try harder to verify LiveStacks
Verify the LiveStacks analysis after a pass that claims to preserve it,
even if there are no further passes (apart from the verifier itself)
that would use the analysis.
Differential Revision: https://reviews.llvm.org/D129200
jacquesguan [Mon, 11 Jul 2022 03:03:48 +0000 (11:03 +0800)]
[mlir][Math] Support fold SqrtOp with constant dense.
This patch uses constFoldUnaryOpConditional to replace current folder in order to support constant dense.
Reviewed By: rriddle
Differential Revision: https://reviews.llvm.org/D129459
Nikita Popov [Mon, 11 Jul 2022 15:17:50 +0000 (17:17 +0200)]
[SDAG] Don't duplicate ParseConstraints() implementation SDAGBuilder (NFCI)
visitInlineAsm() in SDAGBuilder was duplicating a lot of the code
in ParseConstraints(), in particular all the logic to determine the
operand value and constraint VT.
Rely on the data computed by ParseConstraints() instead, and update
its ConstraintVT implementation to match getCallOperandValEVT()
more precisely.
Rosie Sumpter [Thu, 30 Jun 2022 11:15:00 +0000 (12:15 +0100)]
[AArch64][SVE] Ensure PTEST operands have type nxv16i1
Currently any legal predicate types will be pattern-matched when
creating a PTEST instruction. This could be a problem in future since
PTEST always uses the .B specifier for the operand, but it is not
always guaranteed that the extra lanes of unpacked types (e.g. nxv4i1)
are zero. This patch ensures the operands of PTEST are type nxv16i1,
where the undef lanes are set to zero.
Differential Revision: https://reviews.llvm.org/D129282/
Cullen Rhodes [Tue, 12 Jul 2022 07:55:55 +0000 (07:55 +0000)]
[MCA] Support multiple comma-separated -mattr features
Reviewed By: myhsu
Differential Revision: https://reviews.llvm.org/D129479
Denis Revunov [Tue, 12 Jul 2022 07:31:18 +0000 (03:31 -0400)]
[BOLT][AArch64] Use all supported CPU features on AArch64
Since we now have +all feature for AArch64 disassembler, we can use it
in BOLT and allow it to disassemble all ARM instructions supported by LLVM.
Reviewed by: rafauler
Differential Revision: https://reviews.llvm.org/D129139
Pavel Labath [Mon, 11 Jul 2022 14:56:04 +0000 (16:56 +0200)]
[lldb/libc++] Simplify the libc++ string formatter
Precise string layout has changed a lot recently, but a long of these
changes did not have any effect on the usages of its fields -- e.g.
introduction/removal of an anonymous struct or union does not change the
way one can access the field in C++. Our name-based variable lookup
rules (deliberately) copy the C++ semantics, which means these changes
would have been invisible to the them, if only we were using name-based
lookup.
This patch replaces the opaque child index accesses with name-based
lookups, which allows us to greatly simplify the data formatter code.
The formatter continues to support all the string layouts that it
previously supported.
It is unclear why the formatter was not using this approach from the
beginning. I would speculate that the original version was working
around some (now fixed) issue with anonymous members or base classes,
and the subsequent revisions stuck with that approach out of inertia.
Differential Revision: https://reviews.llvm.org/D129490
Manuel Klimek [Tue, 12 Jul 2022 07:42:34 +0000 (07:42 +0000)]
Fix build errors.
Guillaume Chatelet [Thu, 30 Jun 2022 13:04:57 +0000 (13:04 +0000)]
[libc][utils] Add more methods to StringView
Differential Revision: https://reviews.llvm.org/D128908
Nikita Popov [Fri, 8 Jul 2022 14:54:49 +0000 (16:54 +0200)]
[IR] Remove support for float binop constant expressions
As part of https://discourse.llvm.org/t/rfc-remove-most-constant-expressions/63179,
this removes support for the floating-point binop constant expressions
fadd, fsub, fmul, fdiv and frem.
As part of this change, the C APIs LLVMConstFAdd, LLVMConstFSub,
LLVMConstFMul, LLVMConstFDiv and LLVMConstFRem are removed.
The LLVMBuild APIs should be used instead.
Differential Revision: https://reviews.llvm.org/D129478
Ulrich Weigand [Tue, 12 Jul 2022 07:37:19 +0000 (09:37 +0200)]
[mlir] XFAIL IR/elements-attr-interface.mlir on SystemZ
This is still failing as endianness of binary blob external
resources is still not handled correctly.
Ulrich Weigand [Tue, 12 Jul 2022 07:29:07 +0000 (09:29 +0200)]
Read/write external resource alignment tag in little-endian
https://reviews.llvm.org/D126446 added support for encoding
binary blobs in MLIR assembly. To enable cross-architecture
compatibility, these need to be encoded in little-endian format.
This patch is a first step in that direction by reading and
writing the alignment tag that those blobs are prefixed by
in little-endian format. This fixes assertion failures in
several test cases on big-endian platforms.
The actual content of the blob is not yet handled here.
Differential Revision: https://reviews.llvm.org/D129483
Jean Perier [Tue, 12 Jul 2022 07:26:16 +0000 (09:26 +0200)]
[flang] Merge GEPs in substring fir.embox codegen
When computing the base addresses of an array slice to make a
descriptor, codegen generated two LLVM GEPs. The first to compute
the address of the base character element, and a second one to
compute the substring base inside that element.
The previous code did not care about getting the result of the first
GEP right: it used the base array LLVM type as the result type.
This used to work when opaque pointer were not enabled (the actual GEP
result type was probably applied in some later pass). But with opaque
pointers, the second GEP ends-up computing an offset of len*<LLVM array
type> instead of len*<character width>. A previous attempt to fix the
issue was done in D129079, but it does not cover the cases where the
array slice contains subcomponents before the substring
(e.g: array(:)%char_field(5:10)).
This patch fix the issue by computing the actual GEP result type in
codegen. There is also enough knowledge now so that a single GEP can be
generated instead of two.
Differential Revision: https://reviews.llvm.org/D129481
Jean Perier [Tue, 12 Jul 2022 07:22:13 +0000 (09:22 +0200)]
[flang] move getKindMapping() calls out of FIROpBuilder ctor calls
FirOpBuilder takes a fir::KindMapping reference. When the getKindMapping()
call is made inside the ctor call, the lifetime of this reference may
be as short as the ctor call (at least with when building flang in
release mode with clang 8). This can cause segfaults when later using
the FirOpBuilder.
Ensure the kindMap passed to the FirOpBuilder ctor is the same as the
FirOpBuilder.
Differential Revision: https://reviews.llvm.org/D129494
LLVM GN Syncbot [Tue, 12 Jul 2022 07:12:21 +0000 (07:12 +0000)]
[gn build] Port
d6d0dc1f4537
Manuel Klimek [Fri, 25 Sep 2020 12:25:08 +0000 (14:25 +0200)]
[clang-format] Add MacroUnexpander.
MacroUnexpander applies the structural formatting of expanded lines into
UnwrappedLines to the corresponding unexpanded macro calls, resulting in
UnwrappedLines for the macro calls the user typed.
Differential Revision: https://reviews.llvm.org/D88299
Johannes Reifferscheid [Thu, 7 Jul 2022 18:36:41 +0000 (20:36 +0200)]
Fix linalg.dot over boolean tensors.
dot is currently miscompiled for booleans (uses add instead of or).
Reviewed By: bkramer
Differential Revision: https://reviews.llvm.org/D129292
Craig Topper [Tue, 12 Jul 2022 06:28:57 +0000 (23:28 -0700)]
[RISCV] Use X0 in place of VLMaxSentinel in lowering.
I thought I had already fixed all of these, but I guess I missed one.
Carlos Alberto Enciso [Tue, 12 Jul 2022 05:37:29 +0000 (06:37 +0100)]
Update the Windows packaging script.
As discussed on:
https://discourse.llvm.org/t/build-llvm-release-bat-script-options/63146/6
Latest 7-zip versions (21.x) require administrator permissions
to create symbolic links.
Check if any of the following conditions is true:
- Version of 7-zip is 20.x or older
- Script is running with administrator permissions
Reviewed By: hans, thieta
Differential Revision: https://reviews.llvm.org/D129263
Raul Tambre [Fri, 8 Jul 2022 16:38:22 +0000 (19:38 +0300)]
[libc++] Undeprecate ATOMIC_FLAG_INIT (LWG3659)
According to @aaron.ballman this was marked Tentatively Ready as of 2022-07-07.
D129362 implemented the C counterpart.
Reviewed By: ldionne, #libc, Mordante
Differential Revision: https://reviews.llvm.org/D129380
River Riddle [Fri, 8 Jul 2022 02:58:51 +0000 (19:58 -0700)]
[mlir] Add support for regex within `expected-*` diagnostics
This can be enabled by using a `-re` suffix when defining the expected line,
e.g. `expected-error-re`. This support is similar to what clang provides in its "expected"
diagnostic framework(e.g. the `-re` is also the same). The regex definitions themselves are
similar to FileCheck in that regex blocks are specified within `{{` `}}` blocks.
Differential Revision: https://reviews.llvm.org/D129343
Luo, Yuanke [Tue, 12 Jul 2022 03:43:58 +0000 (11:43 +0800)]
[X86] Add test case for interleave shuffle for sub/add
Kazu Hirata [Tue, 12 Jul 2022 03:41:12 +0000 (20:41 -0700)]
[flang] Use has_value instead of hasValue (NFC)
This patch replaces hasValue with has_value in an effort to deprecate
Optional<X>::hasValue.
Differential Revision: https://reviews.llvm.org/D129458
Kazu Hirata [Tue, 12 Jul 2022 03:15:24 +0000 (20:15 -0700)]
[IPO] Remove addLTOOptimizationPasses and addLateLTOOptimizationPasses (NFC)
The last uses were removed on Apr 15, 2022 in commit
2e6ac54cf48aa04f7b05c382c33135b16d3f01ea.
Differential Revision: https://reviews.llvm.org/D129460
Xiang1 Zhang [Tue, 12 Jul 2022 02:16:24 +0000 (10:16 +0800)]
[X86] Support -mstack-protector-guard-symbol
Reviewed By: nickdesaulniers
Differential Revision: https://reviews.llvm.org/D129346
Xiang1 Zhang [Tue, 12 Jul 2022 02:14:32 +0000 (10:14 +0800)]
Revert "[X86] Support -mstack-protector-guard-symbol"
This reverts commit
efbaad1c4a526e91b034e56386e98a9268cd87b2.
due to miss adding review info.
Xiang1 Zhang [Fri, 8 Jul 2022 02:14:49 +0000 (10:14 +0800)]
[X86] Support -mstack-protector-guard-symbol
David Blaikie [Tue, 12 Jul 2022 01:40:57 +0000 (01:40 +0000)]
Add missing include for std::size_t
Joseph Huber [Tue, 12 Jul 2022 01:30:12 +0000 (21:30 -0400)]
[Clang] Fix tests failing due to invalid syntax for host triple
Summary:
We use the `--host-triple=` argument to manually set the target triple.
This was changed to include the `=` previously but was not included in
these additional test cases, causing it for fail on some unsupported
systems.
David Blaikie [Tue, 12 Jul 2022 01:10:31 +0000 (01:10 +0000)]
Rafael Auler [Tue, 12 Jul 2022 00:58:32 +0000 (17:58 -0700)]
[BOLT] Restrict execution of tests that fail on Windows
Turn off execution of tests that use UNIX-specific features.
Reviewed By: Amir
Differential Revision: https://reviews.llvm.org/D126933
Argyrios Kyrtzidis [Tue, 12 Jul 2022 00:42:17 +0000 (17:42 -0700)]
[DependencyScanningTool.cpp] Use `using namespace` instead of wrapping the `.cpp` file contents in namespaces, NFC
This makes the file consistent with the coding style of the rest of LLVM.
Rafael Auler [Sat, 21 May 2022 03:10:22 +0000 (20:10 -0700)]
[BOLT] Increase coverage of shrink wrapping [5/5]
Add -experimental-shrink-wrapping flag to control when we
want to move callee-saved registers even when addresses of the stack
frame are captured and used in pointer arithmetic, making it more
challenging to do alias analysis to prove that we do not access
optimized stack positions. This alias analysis is not yet implemented,
hence, it is experimental. In practice, though, no compiler would emit
code to do pointer arithmetic to access a saved callee-saved register
unless there is a memory bug or we are failing to identify a
callee-saved reg, so I'm not sure how useful it would be to formally
prove that.
Reviewed By: Amir
Differential Revision: https://reviews.llvm.org/D126115
Rafael Auler [Wed, 9 Mar 2022 18:46:15 +0000 (10:46 -0800)]
[BOLT] Increase coverage of shrink wrapping [4/5]
Change shrink-wrapping to try a priority list of save
positions, instead of trying the best one and giving up if it doesn't
work. This also increases coverage.
Reviewed By: Amir
Differential Revision: https://reviews.llvm.org/D126114
Rafael Auler [Sat, 21 May 2022 02:43:07 +0000 (19:43 -0700)]
[BOLT] Increase coverage of shrink wrapping [3/5]
Add the option to run -equalize-bb-counts before shrink
wrapping to avoid unnecessarily optimizing some CFGs where profile is
inaccurate but we can prove two blocks have the same frequency.
Reviewed By: Amir
Differential Revision: https://reviews.llvm.org/D126113
Rafael Auler [Sat, 21 May 2022 02:31:07 +0000 (19:31 -0700)]
[BOLT] Increase coverage of shrink wrapping [2/5]
Refactor isStackAccess() to reflect updates by D126116. Now we only
handle simple stack accesses and delegate the rest of the cases to
getMemDataSize.
Reviewed By: Amir
Differential Revision: https://reviews.llvm.org/D126112
Rafael Auler [Wed, 9 Mar 2022 18:46:15 +0000 (10:46 -0800)]
[BOLT] Increase coverage of shrink wrapping [1/5]
Change how function score is calculated and provide more
detailed statistics when reporting back frame optimizer and shrink
wrapping results. In this new statistics, we provide dynamic coverage
numbers. The main metric for shrink wrapping is the number of executed
stores that were saved because of shrink wrapping (push instructions
that were either entirely moved away from the hot block or converted
to a stack adjustment instruction). There is still a number of reduced
load instructions (pop) that we are not counting at the moment. Also
update alloc combiner to report dynamic numbers, as well as frame
optimizer.
For debugging purposes, we also include a list of top 10 functions
optimized by shrink wrapping. These changes are aimed at better
understanding the impact of shrink wrapping in a given binary.
We also remove an assertion in dataflow analysis to do not choke on
empty functions (which makes no sense).
Reviewed By: Amir
Differential Revision: https://reviews.llvm.org/D126111