Jennifer Yu [Mon, 4 Oct 2021 23:54:47 +0000 (16:54 -0700)]
Fix assert of "Unable to find base lambda address" from
adjustMemberOfForLambdaCaptures.
The problem is happening when user passes lambda function with reference
type in the map clause.
The natural of the problem when processing generateInfoForCapture,
the BasePointer is generated with new load for a lambda variable with
reference type. It is not expected in adjustMemberOfForLambdaCaptures.
One way to fix this is to skipping call to generateInfoForCapture for
map(to:lambda). The map info will be generated later in the call to
generateDefaultMapInfo samiler as firsprivate clase.
This to fix https://bugs.llvm.org/show_bug.cgi?id=52071
Differential Revision:https://reviews.llvm.org/D111115
Leonard Chan [Wed, 6 Oct 2021 21:00:31 +0000 (14:00 -0700)]
[clang][Fuchsia] Add -static-libgcc to TSAN tests
This will ensure that tsan tests are built with the built libunwind.a
rather than the host libunwind.so.
peter klausler [Thu, 30 Sep 2021 22:33:19 +0000 (15:33 -0700)]
[flang] Catch mismatched parentheses in prescanner
Source lines with mismatched parentheses are hard cases for error
recovery in parsing, and the best error message (viz.,
"here's an unmatched parenthesis") can be emitted from the
prescanner.
Differential Revision: https://reviews.llvm.org/D111254#3046173
Leonard Chan [Wed, 6 Oct 2021 20:57:24 +0000 (13:57 -0700)]
Reland "[clang][Fuchsia] Re-enable compiler-rt tests in runtimes build"
This reverts commit
95f824ad7c2da1e8142dbade4e4e12f389f1eb78.
We should've addressed the remaining issues on our CI builders.
Leonard Chan [Wed, 6 Oct 2021 20:53:26 +0000 (13:53 -0700)]
[compiler-rt][memprof] Disambiguate checks for __tls_get_addr in output
TestCases/stress_dtls.c was failing when we ran memprof tests for the first
time. The test checks that __tls_get_addr is not in the output for the last
run when it is possible for the interceptor __interceptor___tls_get_addr to
be in the output from stack dumps. The test actually intends to check that
the various __tls_get_addr reports don't get emitted when intercept_tls_get_addr=0.
This updates the test to also check for the following `:` and preceding `==`
which should ignore the __interceptor___tls_get_addr interceptor.
Differential Revision: https://reviews.llvm.org/D111192
Arthur Eubanks [Wed, 6 Oct 2021 20:50:42 +0000 (13:50 -0700)]
size_t -> uint64_t after
05392466
Fixes some bots where the two differ.
Arthur O'Dwyer [Wed, 6 Oct 2021 20:40:08 +0000 (16:40 -0400)]
[libc++] [test] s/ContiguousView/MoveOnlyView/g. NFCI.
The unique (ha!) thing about this range type is that it's move-only.
Its contiguity is unsurprising (most of our test ranges are contiguous).
Discussed in D111231 but committed separately for clarity.
Arthur O'Dwyer [Tue, 5 Oct 2021 17:31:59 +0000 (13:31 -0400)]
[libc++] [test] Change a lot of free begin/end pairs to members. NFCI.
If you have a `begin() const` member, you don't need a `begin()` member
unless you want it to do something different (e.g. have a different return
type). So in general, //view// types don't need `begin()` non-const members.
Also, static_assert some things about the types in "types.h", so that we
don't accidentally break those properties under refactoring.
Differential Revision: https://reviews.llvm.org/D111231
Arthur Eubanks [Tue, 14 Sep 2021 20:09:23 +0000 (13:09 -0700)]
[clang] Add option to clear AST memory before running LLVM passes
This is to save memory for Clang compiles.
Measuring building PassBuilder.cpp under /usr/bin/time, max rss goes from 0.93GB to 0.7GB.
This does not turn it by default yet.
I've turned on the option locally and run it over a good amount of files without any issues.
For more background, see
https://lists.llvm.org/pipermail/cfe-dev/2021-September/068930.html.
Reviewed By: dblaikie
Differential Revision: https://reviews.llvm.org/D111105
Arthur Eubanks [Fri, 24 Sep 2021 22:54:17 +0000 (15:54 -0700)]
Reland [IR] Increase max alignment to 4GB
Currently the max alignment representable is 1GB, see D108661.
Setting the align of an object to 4GB is desirable in some cases to make sure the lower 32 bits are clear which can be used for some optimizations, e.g. https://crbug.com/1016945.
This uses an extra bit in instructions that carry an alignment. We can store 15 bits of "free" information, and with this change some instructions (e.g. AtomicCmpXchgInst) use 14 bits.
We can increase the max alignment representable above 4GB (up to 2^62) since we're only using 33 of the 64 values, but I've just limited it to 4GB for now.
The one place we have to update the bitcode format is for the alloca instruction. It stores its alignment into 5 bits of a 32 bit bitfield. I've added another field which is 8 bits and should be future proof for a while. For backward compatibility, we check if the old field has a value and use that, otherwise use the new field.
Updating clang's max allowed alignment will come in a future patch.
Reviewed By: hans
Differential Revision: https://reviews.llvm.org/D110451
LLVM GN Syncbot [Wed, 6 Oct 2021 20:22:05 +0000 (20:22 +0000)]
[gn build] Port
67231650e6ef
Michał Górny [Wed, 6 Oct 2021 09:45:27 +0000 (11:45 +0200)]
[lldb] [ABI/X86] Split base x86 and i386 classes
Split the ABIX86 class into two classes: base ABIX86 class that is
common to 32-bit and 64-bit ABIs, and ABIX86_i386 class that is the base
for 32-bit ABIs. This removes the confusing concept that ABIX86
initializes 64-bit ABIs but is only the base for 32-bit ABIs.
Differential Revision: https://reviews.llvm.org/D111216
Nikita Popov [Tue, 5 Oct 2021 21:21:25 +0000 (23:21 +0200)]
[SCEV] Avoid unnecessary domination checks (NFC)
When determining the defining scope, avoid repeatedly querying
dominationg against the function entry instruction. This ends up
begin a very common case that we can handle more efficiently.
Roman Lebedev [Wed, 6 Oct 2021 19:51:27 +0000 (22:51 +0300)]
[NFC][X86][LoopVectorize] Autogenerate check lines in a few tests for ease of updating
For D111220
Louis Dionne [Wed, 3 Feb 2021 21:25:06 +0000 (16:25 -0500)]
[libc++] Use init_priority(100) when possible
Priorities below 101 are reserved for the implementation, so that's what
we should be using here. That is unfortunately only supported on more
recent versions of Clang. See https://reviews.llvm.org/D31413 for details.
Differential Revision: https://reviews.llvm.org/D95972
Louis Dionne [Thu, 30 Sep 2021 17:23:39 +0000 (13:23 -0400)]
[libc++] Simplify writing testing config files
Reduce code duplication by sharing most of the test suite setup across
the different from-scratch configs.
Differential Revision: https://reviews.llvm.org/D111196
Nico Weber [Wed, 6 Oct 2021 19:41:35 +0000 (15:41 -0400)]
[gn build] (manually) port
77d5ccdc6f460
(similar to
64f623d4c37c6)
Chris Lattner [Wed, 6 Oct 2021 16:53:50 +0000 (09:53 -0700)]
[APInt] Fix isAllOnes and extractBits for zero width values.
isAllOnes() should return true for zero bit values because
there are no zeros in it.
Thanks to Jay Foad for pointing this out.
Differential Revision: https://reviews.llvm.org/D111241
Mogball [Tue, 21 Sep 2021 20:54:07 +0000 (20:54 +0000)]
[MLIR] Split arith dialect from the std dialect
Create the Arithmetic dialect that contains basic integer and floating
point arithmetic operations. Ops that did not meet this criterion were
moved to the Math dialect.
First of two atomic patches to remove integer and floating point
operations from the standard dialect. Ops will be removed from the
standard dialect in a subsequent patch.
Reviewed By: ftynse, silvas
Differential Revision: https://reviews.llvm.org/D110200
Philip Reames [Wed, 6 Oct 2021 19:15:16 +0000 (12:15 -0700)]
[scev] minor style improvement [nfc]
Philip Reames [Wed, 6 Oct 2021 19:02:44 +0000 (12:02 -0700)]
[tests] precommit test changes for D111191
peter klausler [Fri, 1 Oct 2021 21:40:40 +0000 (14:40 -0700)]
[flang] Define IEEE_SCALB, IEEE_NEXT_AFTER, IEEE_NEXT_DOWN, IEEE_NEXT_UP
These functions were missing from the standard intrinsic module
IEEE_ARITHMETIC. IEEE_SCALB is an alias for the standard intrinsic
function SCALE(), and the others are defined as new builtin intrinsic
functions.
Differential Revision: https://reviews.llvm.org/D111253
Dan Liew [Wed, 6 Oct 2021 16:41:51 +0000 (09:41 -0700)]
Disable SANITIZER_CHECK_DEADLOCKS on Darwin platforms.
Although THREADLOCAL variables are supported on Darwin they cannot be
used very early on during process init (before dyld has set it up).
Unfortunately the checked lock is used before dyld has setup TLS leading
to an abort call (`_tlv_boostrap()` is never supposed to be called at
runtime).
To avoid this problem `SANITIZER_CHECK_DEADLOCKS` is now disabled on
Darwin platforms. This fixes running TSan tests (an possibly other
Sanitizers) when `COMPILER_RT_DEBUG=ON`.
For reference the crashing backtrace looks like this:
```
* thread #1, stop reason = signal SIGABRT
* frame #0: 0x00000002044da0ae dyld`__abort_with_payload + 10
frame #1: 0x00000002044f01af dyld`abort_with_payload_wrapper_internal + 80
frame #2: 0x00000002044f01e1 dyld`abort_with_payload + 9
frame #3: 0x000000010c989060 dyld_sim`abort_with_payload + 26
frame #4: 0x000000010c94908b dyld_sim`dyld4::halt(char const*) + 375
frame #5: 0x000000010c988f5c dyld_sim`abort + 16
frame #6: 0x000000010c96104f dyld_sim`dyld4::APIs::_tlv_bootstrap() + 9
frame #7: 0x000000010cd8d6d2 libclang_rt.tsan_iossim_dynamic.dylib`__sanitizer::CheckedMutex::LockImpl(this=<unavailable>, pc=<unavailable>) at sanitizer_mutex.cpp:218:58 [opt]
frame #8: 0x000000010cd8a0f7 libclang_rt.tsan_iossim_dynamic.dylib`__sanitizer::Mutex::Lock() [inlined] __sanitizer::CheckedMutex::Lock(this=0x000000010d733c90) at sanitizer_mutex.h:124:5 [opt]
frame #9: 0x000000010cd8a0ee libclang_rt.tsan_iossim_dynamic.dylib`__sanitizer::Mutex::Lock(this=0x000000010d733c90) at sanitizer_mutex.h:162:19 [opt]
frame #10: 0x000000010cd8a0bf libclang_rt.tsan_iossim_dynamic.dylib`__sanitizer::GenericScopedLock<__sanitizer::Mutex>::GenericScopedLock(this=0x000000030c7479a8, mu=<unavailable>) at sanitizer_mutex.h:364:10 [opt]
frame #11: 0x000000010cd89819 libclang_rt.tsan_iossim_dynamic.dylib`__sanitizer::GenericScopedLock<__sanitizer::Mutex>::GenericScopedLock(this=0x000000030c7479a8, mu=<unavailable>) at sanitizer_mutex.h:363:67 [opt]
frame #12: 0x000000010cd8985b libclang_rt.tsan_iossim_dynamic.dylib`__sanitizer::LibIgnore::OnLibraryLoaded(this=0x000000010d72f480, name=0x0000000000000000) at sanitizer_libignore.cpp:39:8 [opt]
frame #13: 0x000000010cda7aaa libclang_rt.tsan_iossim_dynamic.dylib`__tsan::InitializeLibIgnore() at tsan_interceptors_posix.cpp:219:16 [opt]
frame #14: 0x000000010cdce0bb libclang_rt.tsan_iossim_dynamic.dylib`__tsan::Initialize(thr=0x0000000110141400) at tsan_rtl.cpp:403:3 [opt]
frame #15: 0x000000010cda7b8e libclang_rt.tsan_iossim_dynamic.dylib`__tsan::ScopedInterceptor::ScopedInterceptor(__tsan::ThreadState*, char const*, unsigned long) [inlined] __tsan::LazyInitialize(thr=0x0000000110141400) at tsan_rtl.h:665:5 [opt]
frame #16: 0x000000010cda7b86 libclang_rt.tsan_iossim_dynamic.dylib`__tsan::ScopedInterceptor::ScopedInterceptor(this=0x000000030c747af8, thr=0x0000000110141400, fname=<unavailable>, pc=
4568918787) at tsan_interceptors_posix.cpp:247:3 [opt]
frame #17: 0x000000010cda7bb9 libclang_rt.tsan_iossim_dynamic.dylib`__tsan::ScopedInterceptor::ScopedInterceptor(this=0x000000030c747af8, thr=<unavailable>, fname=<unavailable>, pc=<unavailable>) at tsan_interceptors_posix.cpp:246:59 [opt]
frame #18: 0x000000010cdb72b7 libclang_rt.tsan_iossim_dynamic.dylib`::wrap_strlcpy(dst="\xd2", src="0xd1d398d1bb0a007b", size=20) at sanitizer_common_interceptors.inc:7386:3 [opt]
frame #19: 0x0000000110542b03 libsystem_c.dylib`__guard_setup + 140
frame #20: 0x00000001104f8ab4 libsystem_c.dylib`_libc_initializer + 65
...
```
rdar://
83723445
Differential Revision: https://reviews.llvm.org/D111243
Philip Reames [Wed, 6 Oct 2021 18:50:51 +0000 (11:50 -0700)]
Returning poison from a function w/ noundef return attribute is UB
This does for readability of returns within said function as what we do for the caller side when reasoning about what might be poison.
Differential Revision: https://reviews.llvm.org/D111180
Wolfgang Pieb [Tue, 5 Oct 2021 17:28:46 +0000 (10:28 -0700)]
[UBSAN][PS4] For the PS4 target, emit the ud2 ocpode for ubsan traps.
Reviewed By: probinson
Differential Revision: https://reviews.llvm.org/D111172
rdzhabarov [Wed, 6 Oct 2021 18:22:09 +0000 (18:22 +0000)]
[mlir] Fix redundant return in the void method.
clang-tidy, fix redundant return statement at the end of the void method.
Reviewed By: jpienaar
Differential Revision: https://reviews.llvm.org/D111251
wlei [Thu, 30 Sep 2021 02:15:37 +0000 (19:15 -0700)]
[llvm-profgen] Support symbol list for accurate profile
Differential Revision: https://reviews.llvm.org/D110859
Arthur Eubanks [Wed, 6 Oct 2021 18:35:27 +0000 (11:35 -0700)]
Revert "Reland [IR] Increase max alignment to 4GB"
This reverts commit
8d64314ffea55f2ad94c1b489586daa8ce30f451.
Arthur Eubanks [Wed, 6 Oct 2021 18:27:21 +0000 (11:27 -0700)]
Update some types after D110451
To fix mismatched size_t vs uint64_t on some platforms.
Stefan Pintilie [Wed, 22 Sep 2021 16:44:55 +0000 (11:44 -0500)]
[PowerPC] Fix issue with lowering byval parameters.
Lowering of byval parameters with sizes that are not represented by a single
store require multiple stores to properly address the correct size of the
parameter.
Sizes that cannot be done with a single store are 3 bytes, 5 bytes, 6 bytes,
7 bytes. It is not correct to simply perform an 8 byte store and for these
elements because then the store would be larger than the element and alias
analysis would assume that this is undefined behaivour and return NoAlias
for them.
This patch adds the correct stores so that the size of the store is not larger
than the size of the element.
Reviewed By: nemanjai, #powerpc
Differential Revision: https://reviews.llvm.org/D108795
Joe Loser [Wed, 6 Oct 2021 18:17:02 +0000 (14:17 -0400)]
[libc++] Implement P1391 for string_view
Implement P1391 (https://wg21.link/p1391) which allows
`std::string_view` to be constructible from any contiguous range of
characters.
Note that a different paper (http://wg21.link/P1989) handles the generic
range constructor for `std::string_view`.
Reviewed By: ldionne, Quuxplusone, Mordante, #libc
Differential Revision: https://reviews.llvm.org/D110718
Philip Reames [Wed, 6 Oct 2021 17:35:01 +0000 (10:35 -0700)]
[SCEV] Infer flags from add/gep in any block
This patch removes a compile time restriction from isSCEVExprNeverPoison. We've strengthened our ability to reason about flags on scopes other than addrecs, and this bailout prevents us from using it. The comment is also suspect as well in that we're in the middle of constructing a SCEV for I. As such, we're going to visit all operands *anyways*.
Differential Revision: https://reviews.llvm.org/D111186
Simon Pilgrim [Wed, 6 Oct 2021 17:49:03 +0000 (18:49 +0100)]
[CostModel][TTI] Replace BAD_ICMP_PREDICATE with ICMP_NE for generic smulo/umulo cost expansion
Match the predicate used in TargetLowering::expandMULO to detect overflow
Simon Pilgrim [Wed, 6 Oct 2021 17:30:05 +0000 (18:30 +0100)]
[CostModel][TTI] Fix ops used for generic smulo/umulo cost expansion
Fix copy+pasta that was checking for smul_fix instead of smul_with_overflow to detected signed values.
The LShr is performed on the extended type as we use it to truncate+extract the upper/hi bits of the extended multiply.
More closely matches the default expansion from TargetLowering::expandMULO
Simon Pilgrim [Wed, 6 Oct 2021 16:23:14 +0000 (17:23 +0100)]
[CostModel][TTI] Replace BAD_ICMP_PREDICATE with ICMP_ULT/UGT for generic uadd/usubo cost expansion
Match the predicates used in TargetLowering::expandUADDSUBO
Leonard Chan [Wed, 6 Oct 2021 18:09:29 +0000 (11:09 -0700)]
[compiler-rt][test] Add shared_unwind requirement
When using a static libunwind, the check_memcpy.c can fail because it checks
that tsan intercepted all memcpy/memmoves in the final binary. Though if the
static libunwind is not instrumented, then this will fail because it may contain
regular memcpy/memmoves.
This adds a new REQUIRES check for ensuring that this test won't run unless a
dynamic libunwind.so is provided.
Differential Revision: https://reviews.llvm.org/D111194
Arthur Eubanks [Fri, 24 Sep 2021 22:54:17 +0000 (15:54 -0700)]
Reland [IR] Increase max alignment to 4GB
Currently the max alignment representable is 1GB, see D108661.
Setting the align of an object to 4GB is desirable in some cases to make sure the lower 32 bits are clear which can be used for some optimizations, e.g. https://crbug.com/1016945.
This uses an extra bit in instructions that carry an alignment. We can store 15 bits of "free" information, and with this change some instructions (e.g. AtomicCmpXchgInst) use 14 bits.
We can increase the max alignment representable above 4GB (up to 2^62) since we're only using 33 of the 64 values, but I've just limited it to 4GB for now.
The one place we have to update the bitcode format is for the alloca instruction. It stores its alignment into 5 bits of a 32 bit bitfield. I've added another field which is 8 bits and should be future proof for a while. For backward compatibility, we check if the old field has a value and use that, otherwise use the new field.
Updating clang's max allowed alignment will come in a future patch.
Reviewed By: hans
Differential Revision: https://reviews.llvm.org/D110451
Craig Topper [Wed, 6 Oct 2021 17:56:52 +0000 (10:56 -0700)]
[X86] Add X86 and X64 prefixes to parity.ll to reduce duplicate check lines. NFC
LLVM GN Syncbot [Wed, 6 Oct 2021 17:59:12 +0000 (17:59 +0000)]
[gn build] Port
10f16bc7b2bf
Stella Stamenova [Wed, 6 Oct 2021 17:56:45 +0000 (10:56 -0700)]
Revert "[lldb] [ABI/X86] Split base x86 and i386 classes"
This change broke the windows lldb bot.
This reverts commit
a30a36f66aea459337999a000c7997b220b25227.
Kevin P. Neal [Wed, 6 Oct 2021 17:49:24 +0000 (13:49 -0400)]
[FPEnv][InstSimplify] Fold constrained X + -0.0 ==> X
Currently the fadd optimizations in InstSimplify don't know how to do this
"X + -0.0 ==> X" fold when using the constrained intrinsics. This adds the
support.
This commit is derived from D106362 with some improvements from D107285.
Differential Revision: https://reviews.llvm.org/D111085
Fangrui Song [Wed, 6 Oct 2021 17:49:25 +0000 (10:49 -0700)]
[Driver][test] Add Debian multiarch lib/clang/14.0.0/x86_64-linux-gnu and include/x86_64-linux-gnu/c++/v1 tests
Vitaly Buka [Tue, 5 Oct 2021 20:49:31 +0000 (13:49 -0700)]
[sanitizer] Switch to StackDepotNode to 64bit hash
Now we can avoid scanning the stack on fast path.
The price is the false stack trace with probability of the hash collision.
This increase performance of lsan by 6% and pre-requirement for stack compression.
Depends on D111182.
Reviewed By: morehouse, dvyukov
Differential Revision: https://reviews.llvm.org/D111183
natashaknk [Wed, 6 Oct 2021 17:29:37 +0000 (10:29 -0700)]
[mlir][tosa] Create basic dynamic shape support for several ops.
Transpose, Matmul and Fully-connected dynamic shape support
Reviewed By: rsuderman
Differential Revision: https://reviews.llvm.org/D111167
Craig Topper [Wed, 6 Oct 2021 17:29:27 +0000 (10:29 -0700)]
[X86] Add test cases for PR52093. NFC
Mogball [Fri, 1 Oct 2021 19:56:38 +0000 (19:56 +0000)]
[MLIR] Update DRR doc with returnType directive
Add missing documentation.
Reviewed By: Chia-hungDuan, jpienaar
Differential Revision: https://reviews.llvm.org/D110964
Arthur Eubanks [Wed, 6 Oct 2021 17:21:17 +0000 (10:21 -0700)]
Revert "[IR] Increase max alignment to 4GB"
This reverts commit
df84c1fe78130a86445d57563dea742e1b85156a.
Breaks some bots
Michael Kruse [Wed, 6 Oct 2021 16:43:29 +0000 (11:43 -0500)]
[Clang][OpenMP] Allow loop-transformations with template parameters.
Clang would reject
#pragma omp for
#pragma omp tile sizes(P)
for (int i = 0; i < 128; ++i) {}
where P is a template parameter, but the loop itself is not
template-dependent. Because P context-dependent, the TransformedStmt
cannot be generated and therefore is nullptr (until the template is
instantiated by TreeTransform). The OMPForDirective would still expect
the a loop is the dependent context and trigger an error.
Fix by introducing a NumGeneratedLoops field to OMPLoopTransformation.
This is used to distinguish the case where no TransformedStmt will be
generated at all (e.g. #pragma omp unroll full) and template
instantiation is needed. In the latter case, delay resolving the
iteration space like when the for-loop itself is template-dependent
until the template instatiation.
A more radical solution would always delay the iteration space analysis
until template instantiation, but would also break many test cases.
Reviewed By: ABataev
Differential Revision: https://reviews.llvm.org/D111124
H.J. Lu [Fri, 10 Sep 2021 13:24:36 +0000 (06:24 -0700)]
[sanitizer] Support Intel CET
1. Include <cet.h> in sanitizer_common/sanitizer_asm.h to mark Intel CET
support when Intel CET is enabled.
2. Add _CET_ENDBR to function entries in assembly codes so that ENDBR
instruction will be generated when Intel CET is enabled.
Reviewed By: dvyukov
Differential Revision: https://reviews.llvm.org/D111185
Frederic Cambus [Wed, 6 Oct 2021 17:07:31 +0000 (22:37 +0530)]
[CMake] Fix typo in error message for LLD in bootstrap builds.
Reviewed By: xgupta
Differential Revision: https://reviews.llvm.org/D110836
Shivam Gupta [Wed, 6 Oct 2021 08:19:59 +0000 (13:49 +0530)]
[NFC] Add doxygen comment for hasFp in RISCVFrameLowering.cpp
Pengxuan Zheng [Tue, 5 Oct 2021 22:16:05 +0000 (15:16 -0700)]
[ARM] Fix a bug in finding a pair of extracts to create VMOVRRD
D100244 missed a check on the ResNo of the extract's operand 0 when finding a
pair of extracts to combine into a VMOVRRD (extract(x, n); extract(x, n+1) ->
VMOVRRD(extract x, n/2)). As a result, it can incorrectly pair an extract(x, n)
with another extract(x:3, n+1) for example. This patch fixes the bug by adding
the proper check on ResNo.
Reviewed By: dmgreen
Differential Revision: https://reviews.llvm.org/D111188
Arthur Eubanks [Fri, 24 Sep 2021 22:54:17 +0000 (15:54 -0700)]
[IR] Increase max alignment to 4GB
Currently the max alignment representable is 1GB, see D108661.
Setting the align of an object to 4GB is desirable in some cases to make sure the lower 32 bits are clear which can be used for some optimizations, e.g. https://crbug.com/1016945.
This uses an extra bit in instructions that carry an alignment. We can store 15 bits of "free" information, and with this change some instructions (e.g. AtomicCmpXchgInst) use 14 bits.
We can increase the max alignment representable above 4GB (up to 2^62) since we're only using 33 of the 64 values, but I've just limited it to 4GB for now.
The one place we have to update the bitcode format is for the alloca instruction. It stores its alignment into 5 bits of a 32 bit bitfield. I've added another field which is 8 bits and should be future proof for a while. For backward compatibility, we check if the old field has a value and use that, otherwise use the new field.
Updating clang's max allowed alignment will come in a future patch.
Reviewed By: hans
Differential Revision: https://reviews.llvm.org/D110451
Arthur Eubanks [Tue, 5 Oct 2021 20:55:31 +0000 (13:55 -0700)]
[clang] Allow printing 64 bit ints in diagnostics
Currently we're limited to 32 bit ints in diagnostics.
With support for 4GB alignments coming soon, we need to report 4GB as the max alignment allowed.
I've tested that this does indeed properly print 2^32.
Reviewed By: rsmith
Differential Revision: https://reviews.llvm.org/D111184
Max Kazantsev [Wed, 6 Oct 2021 15:51:39 +0000 (22:51 +0700)]
[Test] Add LoopPeel test for loops with profile data available
Patch by Dmitry Makogon!
Gabor Marton [Thu, 30 Sep 2021 21:24:17 +0000 (23:24 +0200)]
[analyzer][NFC] Add RangeSet::dump
This tiny change improves the debugging experience of the solver a lot!
Differential Revision: https://reviews.llvm.org/D110911
Geoffrey Martin-Noble [Fri, 6 Aug 2021 22:59:50 +0000 (15:59 -0700)]
[MLIR] Improve debug messages in BuiltinTypes
It's nice for users to have more information when debugging failures and
these are only triggered in a failure path.
Reviewed By: mehdi_amini
Differential Revision: https://reviews.llvm.org/D107676
Alexandre Rames [Tue, 5 Oct 2021 17:53:02 +0000 (10:53 -0700)]
[MLIR] Rename Shape dialect's `join` to `meet`.
For the type lattice, we (now) use the "less specialized or equal" partial
order, leading to the bottom representing the empty set, and the top
representing any type.
This naming is more in line with the generally used conventions, where the top
of the lattice is the full set, and the bottom of the lattice is the empty set.
A typical example is the powerset of a finite set: generally, meet would be the
intersection, and join would be the union.
```
top: {a,b,c}
/ | \
{a,b} {a,c} {b,c}
| X X |
{a} { b } {c}
\ | /
bottom: { }
```
This is in line with the examined lattice representations in LLVM:
* lattice for `BitTracker::BitValue` in `Hexagon/BitTracker.h`
* lattice for constant propagation in `HexagonConstPropagation.cpp`
* lattice in `VarLocBasedImpl.cpp`
* lattice for address space inference code in `InferAddressSpaces.cpp`
Reviewed By: silvas, jpienaar
Differential Revision: https://reviews.llvm.org/D110766
Nikita Popov [Tue, 28 Sep 2021 20:21:37 +0000 (22:21 +0200)]
[BasicAA] Don't unnecessarily extend pointer size
BasicAA GEP decomposition currently performs all calculation on the
maximum pointer size, but at least 64-bit, with an option to double
the size. The code comment claims that this improves analysis power
when working with uint64_t indices on 32-bit systems. However, I don't
see how this can be, at least while maintaining correctness:
When working on canonical code, the GEP indices will have GEP index
size. If the original code worked on uint64_t with a 32-bit size_t,
then there will be truncs inserted before use as a GEP index. Linear
expression decomposition does not look through truncs, so this will
be an opaque value as far as GEP decomposition is concerned. Working
on a wider pointer size does not help here (or have any effect at all).
When working on non-canonical code (before first InstCombine), the
GEP indices are implicitly truncated to GEP index size. The BasicAA
code currently just ignores this fact completely, and pretends that
this truncation doesn't happen. This is incorrect and will be
addressed by D110977.
I believe that for correctness reasons, it is important to work on
the actual GEP index size to properly model potential overflow.
BasicAA tries to patch over the fact that it uses the wrong size
(see adjustToPointerSize), but it only does that in limited cases
(only for constant values, and not all of them either). I'd like to
move this code towards always working on the correct size, and
dropping these artificial pointer size adjustments is the first step
towards that.
Differential Revision: https://reviews.llvm.org/D110657
Sanjay Patel [Wed, 6 Oct 2021 15:32:46 +0000 (11:32 -0400)]
[InstSimplify] (x | y) & (x | !y) --> x
https://alive2.llvm.org/ce/z/QagQMn
This fold is handled by instcombine via SimplifyUsingDistributiveLaws(),
but we are missing the sibliing fold for 'logical and' (implemented with
'select'). Retrofitting the code in instcombine looks much harder
than just adding a small adjustment here, and this is potentially more
efficient and beneficial to other passes.
Sanjay Patel [Wed, 6 Oct 2021 15:06:10 +0000 (11:06 -0400)]
[InstSimplify] add tests for bitwise logic fold of 'and'; NFC
Gabor Marton [Thu, 30 Sep 2021 21:26:22 +0000 (23:26 +0200)]
[analyzer][solver] Fix CmpOpTable handling bug
There is an error in the implementation of the logic of reaching the `Unknonw` tristate in CmpOpTable.
```
void cmp_op_table_unknownX2(int x, int y, int z) {
if (x >= y) {
// x >= y [1, 1]
if (x + z < y)
return;
// x + z < y [0, 0]
if (z != 0)
return;
// x < y [0, 0]
clang_analyzer_eval(x > y); // expected-warning{{TRUE}} expected-warning{{FALSE}}
}
}
```
We miss the `FALSE` warning because the false branch is infeasible.
We have to exploit simplification to discover the bug. If we had `x < y`
as the second condition then the analyzer would return the parent state
on the false path and the new constraint would not be part of the State.
But adding `z` to the condition makes both paths feasible.
The root cause of the bug is that we reach the `Unknown` tristate
twice, but in both occasions we reach the same `Op` that is `>=` in the
test case. So, we reached `>=` twice, but we never reached `!=`, thus
querying the `Unknonw2x` column with `getCmpOpStateForUnknownX2` is
wrong.
The solution is to ensure that we reached both **different** `Op`s once.
Differential Revision: https://reviews.llvm.org/D110910
Michael Forster [Wed, 6 Oct 2021 15:46:26 +0000 (17:46 +0200)]
Revert "[lldb] Remove "dwarf dynamic register size expressions" from RegisterInfo"
This reverts commit
00e704bf080ffeeb9e334fb3ab71594f9aa50969.
This commit should should have updated
llvm/llvm-project/lldb/source/Plugins/ABI/ARC/ABISysV_arc.cpp like the other
architectures.
Michael Kruse [Wed, 6 Oct 2021 15:02:27 +0000 (10:02 -0500)]
[Clang][OpenMP] Infix OMPLoopTransformationDirective abstract class. NFC.
Insert OMPLoopTransformationDirective between OMPLoopBasedDirective and the loop transformations OMPTileDirective and OMPUnrollDirective. This simplifies handling of loop transformations not requiring distinguishing between OMPTileDirective and OMPUnrollDirective anymore.
Reviewed By: ABataev
Differential Revision: https://reviews.llvm.org/D111119
Kazu Hirata [Wed, 6 Oct 2021 15:40:39 +0000 (08:40 -0700)]
Revert "[IR] Remove arg_operands and getNumArgOperands (NFC)"
This reverts commit
c72722f45ef1aa6d78e1e6fee07ab6bd86980da8.
Simon Pilgrim [Wed, 6 Oct 2021 15:09:47 +0000 (16:09 +0100)]
[CostModel][TTI] Replace BAD_ICMP_PREDICATE with ICMP_EQ for generic funnel shift cost expansion
The comparison always checks for zero value so know the icmp predicate will be ICMP_EQ
Louis Dionne [Thu, 30 Sep 2021 19:11:48 +0000 (15:11 -0400)]
[runtimes][ci] Run the tests for libunwind in the CI
We should arguably have always been doing that. The state of libunwind
is quite sad, so this commit adds several XFAILs to make the CI pass.
We need to investigate why so many tests are not passing in some
configurations, but I'll defer that to folks who actually work on
libunwind for lack of bandwidth.
Differential Revision: https://reviews.llvm.org/D110872
Kazu Hirata [Wed, 6 Oct 2021 15:14:35 +0000 (08:14 -0700)]
[IR] Remove arg_operands and getNumArgOperands (NFC)
The last uses were removed on Oct 5, 2021 in commit
3081de8c72fc9b6c0cc8b1bb5f02858b78ebaa4c.
Clement Courbet [Wed, 6 Oct 2021 14:54:17 +0000 (16:54 +0200)]
Nico Weber [Wed, 6 Oct 2021 14:30:14 +0000 (10:30 -0400)]
[clang] Don't mark _ReadBarrier, _ReadWriteBarrier, _WriteBarrier deprecated
It's true that docs.microsoft.com says:
"""The _ReadBarrier, _WriteBarrier, and _ReadWriteBarrier compiler
intrinsics and the MemoryBarrier macro are all deprecated and should not
be used. For inter-thread communication, use mechanisms such as
atomic_thread_fence and std::atomic<T>, which are defined in the C++
Standard Library. For hardware access, use the /volatile:iso compiler
option together with the volatile keyword."""
And these attributes have been here since these builtins were added in
r192860.
However:
- cl.exe does not warn on them even with /Wall
- none of the replacements are useful for C code
- we don't add __attribute__((__deprecated__())) to any other
declarations in intrin.h
- intrin0.h in the MSVC headers declares _ReadWriteBarrier() (but
without the deprecation attribute), so you get inconsistent
deprecation warnings depending on if you include intrin.h or intrin0.h
The motivation is that compiling sqlite.h with clang-cl produces a
deprecation warning with clang-cl for _ReadWriteBarrier(), but not with
cl.exe.
Differential Revision: https://reviews.llvm.org/D111232
Clement Courbet [Wed, 6 Oct 2021 14:47:34 +0000 (16:47 +0200)]
Revert "[AA] Teach BasicAA to recognize basic GEP range information."
We have found a miscompile with this change, reverting while working on a
reproducer.
This reverts commit
455b60ccfbfdbb5d2b652666050544c31e6673b1.
Simon Pilgrim [Wed, 6 Oct 2021 14:37:05 +0000 (15:37 +0100)]
[TTI] Remove default condition type and predicate arguments from getCmpSelInstrCost
We need to be better at exposing the comparison predicate to getCmpSelInstrCost calls as some targets (e.g. X86 SSE) have very different costs for different comparisons (PR48337), and we can't always rely on the optional Instruction argument.
This initial commit requires explicit condition type and predicate arguments. The next step will be to review a lot of the existing getCmpSelInstrCost calls which have used BAD_ICMP_PREDICATE even when the predicate is known.
Differential Revision: https://reviews.llvm.org/D111024
Amy Kwan [Tue, 5 Oct 2021 22:21:27 +0000 (17:21 -0500)]
[AIX] Define WCHAR_T_TYPE as unsigned short on AIX for wchar.c test case.
The default wchar type is different on AIX vs. Linux. When this test is run on
AIX, WCHAR_T_TYPE ends up being set to int. This is incorrect as the default
wchar type on AIX is actually unsigned short, and setting the type incorrectly
causes the expected errors to not be found.
This patch sets the type correctly (to unsigned short) for AIX.
Differential Revision: https://reviews.llvm.org/D110428
luxufan [Wed, 6 Oct 2021 13:33:04 +0000 (21:33 +0800)]
Revert "[JITLink][NFC] Add TableManager to replace PerGraph...Builder pass"
This reverts commit
50a278c2aef21bf9b78865ad7c7554e506434b9c.
Simon Pilgrim [Wed, 6 Oct 2021 13:30:31 +0000 (14:30 +0100)]
[Support] ErrorHandling.h - Remove report_fatal_error(std::string)
As described on D111049, removing the <string> dependency from error handling removes considerable build overhead, its recommended that the report_fatal_error(Twine) variant is used instead.
David Green [Wed, 6 Oct 2021 13:32:01 +0000 (14:32 +0100)]
[AArch64] Regenerate even more tests
This updates a few more check lines, in some mte tests that were close
to auto generated already and some CodeGenPrepare/consthoist tests where
being able to see the entire code sequence is useful for determining
whether code differences are improvements or not.
luxufan [Wed, 6 Oct 2021 07:52:25 +0000 (15:52 +0800)]
[JITLink][NFC] Add TableManager to replace PerGraph...Builder pass
This patch add a TableManager which reponsible for fixing edges that need entries to reference the target symbol and constructing such entries.
In the past, the PerGraphGOTAndPLTStubsBuilder pass was used to build GOT and PLT entry, and the PerGraphTLSInfoEntryBuilder pass was used to build TLSInfo entry. By generalizing the behavior of building entry, I added a TableManager which could be reused when built GOT, PLT and TLSInfo entries.
If this patch makes sense and can be accepted, I will apply the TableManager to other targets(MachO_x86_64, MachO_arm64, ELF_riscv), and delete the file PerGraphGOTAndPLTStubsBuilder.h
Reviewed By: lhames
Differential Revision: https://reviews.llvm.org/D110383
Raphael Isemann [Wed, 6 Oct 2021 12:58:50 +0000 (14:58 +0200)]
[lldb] Make 'this' substituton error more verbose.
Raphael Isemann [Wed, 6 Oct 2021 11:08:33 +0000 (13:08 +0200)]
[lldb] Rewrite and extend TestConstThis
Simon Pilgrim [Wed, 6 Oct 2021 12:32:18 +0000 (13:32 +0100)]
[polly] Replace report_fatal_error(std::string) uses with report_fatal_error(Twine)
As described on D111049, we're trying to remove the <string> dependency from error handling and replace uses of report_fatal_error(const std::string&) with the Twine() variant which can be forward declared.
Jaroslav Sevcik [Sat, 25 Sep 2021 17:29:04 +0000 (19:29 +0200)]
Reland "[lldb] Refactor variable parsing"
Separates the methods for recursive variable parsing in function
context and non-recursive parsing of global variables.
Original patch: https://reviews.llvm.org/rG601168e42037ac4433e74b920bb22f76d59ba420
Revert patch: https://reviews.llvm.org/rGca5be065c4c612554acdcae3ead01a1474eff296
Diff from the original patch: avoid using nullptr deref/ref.
Differential Revision: https://reviews.llvm.org/D110570
Sanjay Patel [Wed, 6 Oct 2021 11:42:06 +0000 (07:42 -0400)]
[InstCombine] fold fake vector extract to shift+trunc
We already handle more complicated cases like:
extelt (bitcast (inselt poison, X, 0)) --> trunc (lshr X)
But we missed this simpler pattern:
https://alive2.llvm.org/ce/z/D55h64 / https://alive2.llvm.org/ce/z/GKzzRq
This is part of solving:
https://llvm.org/PR52057
I made the transform depend on legal/desirable int type to avoid creating
a shift of an illegal type (for example i128). I'm not sure if that
restriction is actually necessary, but we can change that as a follow-up
if the backend can deal with integer ops on too-wide illegal types.
The pile of AVX512 test changes are all neutral AFAICT - the x86 backend
seems to know how to turn that into the expected "kmov" instructions.
Differential Revision: https://reviews.llvm.org/D111082
Michał Górny [Wed, 6 Oct 2021 08:45:54 +0000 (10:45 +0200)]
[lldb] [FreeBSD] Fix building on systems without PT_COREDUMP
PT_COREDUMP is a relatively recent addition. Use an #ifdef to skip it
if the underlying system does not support it.
Differential Revision: https://reviews.llvm.org/D111214
Max Kazantsev [Wed, 6 Oct 2021 12:00:50 +0000 (19:00 +0700)]
[Test] Few more symmetrical test for D110517
LLVM GN Syncbot [Wed, 6 Oct 2021 11:59:40 +0000 (11:59 +0000)]
[gn build] Port
a30a36f66aea
Michał Górny [Wed, 6 Oct 2021 09:45:27 +0000 (11:45 +0200)]
[lldb] [ABI/X86] Split base x86 and i386 classes
Split the ABIX86 class into two classes: base ABIX86 class that is
common to 32-bit and 64-bit ABIs, and ABIX86_i386 class that is the base
for 32-bit ABIs. This removes the confusing concept that ABIX86
initializes 64-bit ABIs but is only the base for 32-bit ABIs.
Differential Revision: https://reviews.llvm.org/D111216
Simon Pilgrim [Wed, 6 Oct 2021 11:57:04 +0000 (12:57 +0100)]
[mlir] Replace report_fatal_error(std::string) uses with report_fatal_error(Twine)
As described on D111049, we're trying to remove the <string> dependency from error handling and replace uses of report_fatal_error(const std::string&) with the Twine() variant which can be forward declared.
Pavel Labath [Thu, 23 Sep 2021 12:10:49 +0000 (14:10 +0200)]
[lldb] Remove "dwarf dynamic register size expressions" from RegisterInfo
These were added to support some mips registers on linux, but linux mips
support has now been removed due.
They are still referenced in the freebds mips implementation, but the
completeness of that implementation is also unknown. All other
architectures just set these fields to zero, which is a cause of
significant bloat in our register info definitions.
Arm also has registers with variable sizes, but they were implemented in
a more gdb-compatible fashion and don't use this feature.
Differential Revision: https://reviews.llvm.org/D110914
Amara Emerson [Wed, 6 Oct 2021 06:36:28 +0000 (23:36 -0700)]
Revert "Revert "[GlobalISel][IRTranslator] Emit trap intrinsic for "unreachable"""
This reverts commit
d95cd81141a4e398e0d3337cb2e6617281d06278.
Re-land the original patch now that the bug this exposed in selection has been
fixed by
6bc64e24c38a
Simon Pilgrim [Wed, 6 Oct 2021 11:13:40 +0000 (12:13 +0100)]
[llvm] Unix.h - Replace report_fatal_error(std::string) with report_fatal_error(Twine)
As described on D111049, we're trying to remove the <string> dependency from error handling and replace uses of report_fatal_error(const std::string&) with the Twine() variant which can be forward declared.
Simon Pilgrim [Wed, 6 Oct 2021 11:04:30 +0000 (12:04 +0100)]
[llvm] Replace report_fatal_error(std::string) uses with report_fatal_error(Twine)
As described on D111049, we're trying to remove the <string> dependency from error handling and replace uses of report_fatal_error(const std::string&) with the Twine() variant which can be forward declared.
Simon Pilgrim [Wed, 6 Oct 2021 10:23:26 +0000 (11:23 +0100)]
[clang] Replace report_fatal_error(std::string) uses with report_fatal_error(Twine)
As described on D111049, we're trying to remove the <string> dependency from error handling and replace uses of report_fatal_error(const std::string&) with the Twine() variant which can be forward declared.
Max Kazantsev [Wed, 6 Oct 2021 10:36:36 +0000 (17:36 +0700)]
[Test] Add some more symmetrical test cases for D110517
More similar cases to see that the opt we are trying to make is generic enough.
Vince Bridgers [Tue, 28 Sep 2021 13:42:31 +0000 (08:42 -0500)]
[analyzer] canonicalize special case of structure/pointer deref
This simple change addresses a special case of structure/pointer
aliasing that produced different symbolvals, leading to false positives
during analysis.
The reproducer is as simple as this.
```lang=C++
struct s {
int v;
};
void foo(struct s *ps) {
struct s ss = *ps;
clang_analyzer_dump(ss.v); // reg_$1<int Element{SymRegion{reg_$0<struct s *ps>},0 S64b,struct s}.v>
clang_analyzer_dump(ps->v); //reg_$3<int SymRegion{reg_$0<struct s *ps>}.v>
clang_analyzer_eval(ss.v == ps->v); // UNKNOWN
}
```
Acks: Many thanks to @steakhal and @martong for the group debug session.
Reviewed By: steakhal, martong
Differential Revision: https://reviews.llvm.org/D110625
Nathan Sidwell [Thu, 16 Sep 2021 19:29:37 +0000 (12:29 -0700)]
[X86][NFC] structure-return simplificiation
The X86 backend only needs to know whether structure return is via an
sret pointer. This removes the categorization enumeration and
adjusts, templatizes and renames the related functions.
Differential Revision: https://reviews.llvm.org/D109966
Nicolas Vasilache [Wed, 6 Oct 2021 10:00:50 +0000 (10:00 +0000)]
[mlir][Linalg] Don't return early from inPlaceAnalysis
Instead just emit a warning that analysis failed and the result will be treated conservatively.
Differential Revision: https://reviews.llvm.org/D111217
David Green [Wed, 6 Oct 2021 09:38:22 +0000 (10:38 +0100)]
[AArch64] Regenerate some more tests
This updates the check lines in some extra tests, to make them more
maintainable going forward.
Simon Pilgrim [Tue, 5 Oct 2021 21:12:37 +0000 (22:12 +0100)]
[CostModel][X86] getCmpSelInstrCost - treat BAD_PREDICATEs the same as the worst case cost predicates for ICMP/FCMP instructions
As suggested on D111024, we should treat getCmpSelInstrCost calls without a specific predicate as matching the worst case predicate cost.
These regressions will be addressed with a mixture of D111024 and fixing other specific getCmpSelInstrCost calls to have realistic predicates.
Jonas Paulsson [Wed, 6 Oct 2021 08:48:21 +0000 (10:48 +0200)]
[SystemZ] Temporarily revert memcmp and memcpy patches
Seem to cause test failures in compiler-rt.
Revert "[SystemZ] Implement memcmp of variable length with CLC."
This reverts commit
7a4e9a0c73667cb80e4572d41535a9e48f1ed9ef.
Revert "[SystemZ] Implement memcpy of variable length with MVC."
This reverts commit
c6c13c58eebda605a9a05f1f13cac1e46407afc7.
Muhammad Omair Javaid [Wed, 6 Oct 2021 08:56:44 +0000 (13:56 +0500)]
Round XML register bitsize to byte boundary
This patch allows LLDB to accept register sizes which are not aligned
to 8 bits bitsize boundary. This fixes a crash in LLDB when connecting
to OpenOCD stub. GDB xml description allows for non-aligned bit lengths
but they are rounded off to nearest byte during transfer. In case of
OpenOCD some of SOC specific system registers were less than a single
byte in length and were causing LLDB to crash.
Reviewed By: labath
Differential Revision: https://reviews.llvm.org/D111131