Med Ismail Bennani [Mon, 6 Mar 2023 21:17:43 +0000 (13:17 -0800)]
Revert "[lldb] Move ScriptedProcess private state update to implementation"
This reverts commit
3c33d72e7fa83beb8a9b39fb3b8ecf4ee00c697d.
Med Ismail Bennani [Mon, 6 Mar 2023 21:17:40 +0000 (13:17 -0800)]
Revert "[lldb/API] Introduce SBProcess::ForceScriptedState method"
This reverts commit
3675e0bb67fa86b8476a67bb1a7623a6b1a373b3.
Med Ismail Bennani [Mon, 6 Mar 2023 19:53:09 +0000 (11:53 -0800)]
[lldb/Utility] Fix layering violation caused by ScriptedMetadata
This patch moves `ScriptedMetadata.h` from the `Interpreter` directory to
the `Utility` sub-directory since `ProcessInfo.h` depends on it.
It also gets rid of the unused `OptionGroupPythonClassWithDict`
constructor for `ScriptedMetadata` which would address the layering
violation.
Signed-off-by: Med Ismail Bennani <medismail.bennani@gmail.com>
Med Ismail Bennani [Sat, 4 Mar 2023 05:44:51 +0000 (21:44 -0800)]
[lldb] Add an example of interactive scripted process debugging (NFC)
This patch is a proof of concept that shows how a scripted process could
be used with real process to perform interactive debugging.
In this example, we run a process that spawns 10 threads. Then, we
create a intermediary scripted process who's job will be to wrap the
real process while intercepting it's process events and dispatching them
back either to the real process or to other child scripted processes.
In this example, we have 2 child scripted processes, with even and odd
thread indices. The goal is to be able to do thread filtering and
explore the various interactive debugging approaches, by letting a child
process running when stopping the other process and inspecting it.
Another approach would be to have the child processes execution in-sync
to force running every child process when one of them starts running.
Signed-off-by: Med Ismail Bennani <medismail.bennani@gmail.com>
Med Ismail Bennani [Sat, 4 Mar 2023 05:40:51 +0000 (21:40 -0800)]
[lldb/Plugin] Add breakpoint setting support to ScriptedProcesses.
This patch adds support for breakpoint setting to Scripted Processes.
For now, Scripted Processes only support setting software breakpoints.
When doing interactive scripted process debugging, it makes use of the
memory writing capability to write the trap opcodes in the memory of the
driving process. However the real process' target doesn't keep track of
the breakpoints that got added by the scripted process. This is a design
that we might need to change in the future, since we'll probably need to
do some book keeping to handle breakpoints that were set by different
scripted processes.
Differential Revision: https://reviews.llvm.org/D145296
Signed-off-by: Med Ismail Bennani <medismail.bennani@gmail.com>
Med Ismail Bennani [Sat, 4 Mar 2023 05:39:36 +0000 (21:39 -0800)]
[lldb] Move ScriptedProcess private state update to implementation
While debugging a Scripted Process, in order to update its state and
work nicely with lldb's execution model, it needs to toggle its private
state from running to stopped, which will result in broadcasting a
process state changed event to the debugger listener.
Originally, this state update was done systematically in the Scripted
Process C++ plugin, however in order to make scripted process
interactive, we need to be able to update their state dynamically.
This patch makes use of the recent addition of the
`SBProcess::ForceScriptedState` to programatically, and moves the
process private state update to the python implementation of the `resume`
method instead of doing it in `ScriptedProcess::DoResume`.
This patch also removes the unused `ShouldStop` & `Stop` scripted
process APIs, and adds new ScriptedInterface transform methods for
boolean arguments. This allow the user to programmatically decide if
after running the process, we should stop it (which is the default setting).
Differential Revision: https://reviews.llvm.org/D145295
Signed-off-by: Med Ismail Bennani <medismail.bennani@gmail.com>
Med Ismail Bennani [Sat, 4 Mar 2023 05:37:45 +0000 (21:37 -0800)]
[lldb/API] Introduce SBProcess::ForceScriptedState method
This patch introduces a new method to the SBProcess API called
ForceScriptedState. As the name suggests, this affordance will allow the
user to alter the private state of the scripted process programatically.
This is necessary to update the scripted process state when perform
interactive debugging.
Differential Revision: https://reviews.llvm.org/D145294
Signed-off-by: Med Ismail Bennani <medismail.bennani@gmail.com>
Owen Pan [Mon, 6 Mar 2023 01:52:42 +0000 (17:52 -0800)]
[clang-format] Don't annotate left brace of class as FunctionLBrace
The l_brace of class/struct/union was incorrectly annotated as
TT_FunctionLBrace in the presence of attributes. This in turn
would cause the RemoveSemicolon option to remove the semicolon
at the end of the declaration, resulting in invalid code being
generated.
Fixes #61188.
Differential Revision: https://reviews.llvm.org/D145344
Dave Lee [Sat, 18 Feb 2023 03:53:16 +0000 (19:53 -0800)]
[lldb] Redefine p alias to dwim-print command
Redefine the `p` alias to the `dwim-print` command instead of `expression`.
See https://reviews.llvm.org/D138315 for the introduction of `dwim-print`.
To summarize, `dwim-print` is, as the name suggests, a command for printing. How a value
gets printed, is decided by `dwim-print`. In some cases, `dwim-print` will print values
using the same means as `frame variable` (because it's generally more reliable and
faster that `expression` evaluation), and in other cases `dwim-print` uses the same code
path as `expression`.
This change has been tested in two different ways:
1. Re-aliasing `p` to `dwim-print`, as in this patch
2. Redefinining the `expression` command to `CommandObjectDWIMPrint`
Previously, many of the lldb's tests used `p`, and which meant a test run with `p`
aliases to `dwim-print` was a good way to test `dwim-print`. However most of those tests
were updated to use `expression` explicitly (in anticipation of this change). Now, the
best way to test `dwim-print` is the second approach:
```
diff --git a/lldb/source/Interpreter/CommandInterpreter.cpp b/lldb/source/Interpreter/CommandInterpreter.cpp
index
373c894f34f5..
9c943cd30c7c 100644
--- a/lldb/source/Interpreter/CommandInterpreter.cpp
+++ b/lldb/source/Interpreter/CommandInterpreter.cpp
@@ -539,7 +539,7 @@ void CommandInterpreter::LoadCommandDictionary() {
REGISTER_COMMAND_OBJECT("diagnostics", CommandObjectDiagnostics);
REGISTER_COMMAND_OBJECT("disassemble", CommandObjectDisassemble);
REGISTER_COMMAND_OBJECT("dwim-print", CommandObjectDWIMPrint);
- REGISTER_COMMAND_OBJECT("expression", CommandObjectExpression);
+ REGISTER_COMMAND_OBJECT("expression", CommandObjectDWIMPrint);
REGISTER_COMMAND_OBJECT("frame", CommandObjectMultiwordFrame);
REGISTER_COMMAND_OBJECT("gui", CommandObjectGUI);
REGISTER_COMMAND_OBJECT("help", CommandObjectHelp);
```
When the test suite is run with this change, there are two main categories of test
failures for specific to features that `dwim-print` intentionally doesn't support:
1. Top level expressions (`--top-level`/`-p`)
2. Multiline expressions
In cases where the behavior of `expression` is needed, users can use `expression` at
those times.
Differential Revision: https://reviews.llvm.org/D145189
wren romano [Mon, 6 Mar 2023 20:19:41 +0000 (12:19 -0800)]
[mlir][sparse] Renaming "pointer/index" to "position/coordinate"
The old "pointer/index" names often cause confusion since these names clash with names of unrelated things in MLIR; so this change rectifies this by changing everything to use "position/coordinate" terminology instead.
In addition to the basic terminology, there have also been various conventions for making certain distinctions like: (1) the overall storage for coordinates in the sparse-tensor, vs the particular collection of coordinates of a given element; and (2) particular coordinates given as a `Value` or `TypedValue<MemRefType>`, vs particular coordinates given as `ValueRange` or similar. I have striven to maintain these distinctions
as follows:
* "p/c" are used for individual position/coordinate values, when there is no risk of confusion. (Just like we use "d/l" to abbreviate "dim/lvl".)
* "pos/crd" are used for individual position/coordinate values, when a longer name is helpful to avoid ambiguity or to form compound names (e.g., "parentPos"). (Just like we use "dim/lvl" when we need a longer form of "d/l".)
I have also used these forms for a handful of compound names where the old name had been using a three-letter form previously, even though a longer form would be more appropriate. I've avoided renaming these to use a longer form purely for expediency sake, since changing them would require a cascade of other renamings. They should be updated to follow the new naming scheme, but that can be done in future patches.
* "coords" is used for the complete collection of crd values associated with a single element. In the runtime library this includes both `std::vector` and raw pointer representations. In the compiler, this is used specifically for buffer variables with C++ type `Value`, `TypedValue<MemRefType>`, etc.
The bare form "coords" is discouraged, since it fails to make the dim/lvl distinction; so the compound names "dimCoords/lvlCoords" should be used instead. (Though there may exist a rare few cases where is is appropriate to be intentionally ambiguous about what coordinate-space the coords live in; in which case the bare "coords" is appropriate.)
There is seldom the need for the pos variant of this notion. In most circumstances we use the term "cursor", since the same buffer is reused for a 'moving' pos-collection.
* "dcvs/lcvs" is used in the compiler as the `ValueRange` analogue of "dimCoords/lvlCoords". (The "vs" stands for "`Value`s".) I haven't found the need for it, but "pvs" would be the obvious name for a pos-`ValueRange`.
The old "ind"-vs-"ivs" naming scheme does not seem to have been sustained in more recent code, which instead prefers other mnemonics (e.g., adding "Buf" to the end of the names for `TypeValue<MemRefType>`). I have cleaned up a lot of these to follow the "coords"-vs-"cvs" naming scheme, though haven't done an exhaustive cleanup.
* "positions/coordinates" are used for larger collections of pos/crd values; in particular, these are used when referring to the complete sparse-tensor storage components.
I also prefer to use these unabbreviated names in the documentation, unless there is some specific reason why using the abbreviated forms helps resolve ambiguity.
In addition to making this terminology change, this change also does some cleanup along the way:
* correcting the dim/lvl terminology in certain places.
* adding `const` when it requires no other code changes.
* miscellaneous cleanup that was entailed in order to make the proper distinctions. Most of these are in CodegenUtils.{h,cpp}
Reviewed By: aartbik
Differential Revision: https://reviews.llvm.org/D144773
Yuanfang Chen [Mon, 6 Mar 2023 19:54:18 +0000 (11:54 -0800)]
[NFC][Clang] add test comments for GitHub issue 58896
Per discussions with @erichkeane.
Dave Lee [Mon, 6 Mar 2023 03:26:29 +0000 (19:26 -0800)]
Recommit [lldb] Test 'v' support for direct ivar access (NFC)
Add basic tests for `frame variable`'s ability to direct access fields of `this` and
ivars of `self`.
This splits the tests, preventing ObjC tests from running on Linux.
Differential Revision: https://reviews.llvm.org/D145348
Jakub Kuderski [Mon, 6 Mar 2023 19:39:39 +0000 (14:39 -0500)]
[ADT] Avoid needless iterator copies in `zippy`
Make `zip_common` increment and decrement iterators in place.
This improves performance with iterator types that have non-triviall
copy constructors.
Reviewed By: zero9178
Differential Revision: https://reviews.llvm.org/D145337
Chia-hung Duan [Mon, 6 Mar 2023 19:22:30 +0000 (19:22 +0000)]
[scudo] Make the boundary of memory group aligned with region begin
This alignment guarantee enables simpler group range check while page
releasing and a potential optimization which is, now all the pointers
from the same group are also inth same region, that means the complexity
in markFreeBlocks() can be reduced as well.
Reviewed By: cferris
Differential Revision: https://reviews.llvm.org/D142931
Dave Lee [Mon, 6 Mar 2023 19:12:07 +0000 (11:12 -0800)]
Revert "[lldb] Test 'v' support for direct ivar access (NFC)"
This reverts commit
03e5c46e15b4a196cdca0c646e61f0c92a6dc7e1.
Jan Svoboda [Mon, 6 Mar 2023 18:57:09 +0000 (10:57 -0800)]
[clang][deps] Un-XFAIL test on AIX
Sanjay Patel [Mon, 6 Mar 2023 15:22:58 +0000 (10:22 -0500)]
[InstCombine] fold signed absolute diff patterns
This overlaps partially with the codegen patch D144789. This needs no-wrap
for correctness, and I'm not sure if there's an unsigned equivalent:
https://alive2.llvm.org/ce/z/ErmQ-9
https://alive2.llvm.org/ce/z/mr-c_A
This is obviously an improvement in IR, and it looks like a codegen win
for all targets and data types that I sampled.
The 'nabs' case is left as a potential follow-up (and seems less likely
to occur in real code).
Differential Revision: https://reviews.llvm.org/D145073
Sanjay Patel [Fri, 3 Mar 2023 17:48:59 +0000 (12:48 -0500)]
[InstCombine] use dyn_cast instead of isa+cast; NFC
Dave Lee [Wed, 1 Mar 2023 22:59:31 +0000 (14:59 -0800)]
[lldb] Add variable completion to dwim-print
Enable completion of variables for `dwim-print` command.
Differential Revision: https://reviews.llvm.org/D145124
Dave Lee [Mon, 6 Mar 2023 03:26:29 +0000 (19:26 -0800)]
[lldb] Test 'v' support for direct ivar access (NFC)
Add basic tests for `frame variable`'s ability to direct access fields of `this` and
ivars of `self`.
Differential Revision: https://reviews.llvm.org/D145348
Paul Walker [Mon, 6 Mar 2023 16:13:25 +0000 (16:13 +0000)]
[Bitcode] Add test for constant scalable vector gep.
Goran Flegar [Mon, 6 Mar 2023 18:11:03 +0000 (19:11 +0100)]
[mlir-opt] Fix dialect preload after fb1bb6a
Also pipe empty string to the commandline test to make sure it does
not hang on some configurations.
Simon Pilgrim [Mon, 6 Mar 2023 18:22:30 +0000 (18:22 +0000)]
[X86] combineBitcastvxi1/checkBitcastSrcVectorSize - sign-extend select(i1,vXi1,vXi1) patterns
Fixes #61104
Jay Foad [Mon, 6 Mar 2023 18:09:35 +0000 (18:09 +0000)]
[AMDGPU] Add GFX9,GFX10,GFX11 checks for llvm.amdgcn.s.buffer.load
Jay Foad [Mon, 6 Mar 2023 18:05:48 +0000 (18:05 +0000)]
[AMDGPU] Generate checks for llvm.amdgcn.s.buffer.load
Kazu Hirata [Mon, 6 Mar 2023 18:18:57 +0000 (10:18 -0800)]
[X86] Optimize umax(X,1) (NFC)
Without this patch:
%cond = call i32 @llvm.umax.i32(i32 %X, i32 1)
is compiled as:
83 ff 02 cmp $0x2,%edi
b8 01 00 00 00 mov $0x1,%eax
0f 43 c7 cmovae %edi,%eax
With this patch, the compiler generates:
89 f8 mov %edi,%eax
83 ff 01 cmp $0x1,%edi
83 d0 00 adc $0x0,%eax
saving 3 bytes. We should be able to save 5 bytes in larger functions
where the mov is unnecessary.
This patch converts the specific cmov pattern to cmp $1 followed by
adc $0.
This patch partially fixes:
https://github.com/llvm/llvm-project/issues/60374
The LLVM IR optimizer is yet to canonicalize max expressions to
actual @llvm.umax.
Differential Revision: https://reviews.llvm.org/D144451
Simon Pilgrim [Mon, 6 Mar 2023 18:00:13 +0000 (18:00 +0000)]
[X86] Add Issue #61104 test case
Shows the failure of combineBitcastvxi1 to sign-extend a select(i1,vXi1,vXi1) pattern
Alex MacLean [Mon, 6 Mar 2023 17:16:48 +0000 (09:16 -0800)]
[docs][NewPM] fix typos in new pass manager docs
Fix some minor errors in the code-block sections of the new pass manager documentation
Reviewed By: aeubanks
Differential Revision: https://reviews.llvm.org/D145325
Fangrui Song [Mon, 6 Mar 2023 17:16:57 +0000 (09:16 -0800)]
[Driver] Reject -march= for ppc
Clang -march= for ppc triples currently leads to an
-Wunused-command-line-argument warning but GCC rejects -march=.
error: unrecognized command-line option ‘-march=xxx’
Let's reject -march= as well similar to the Sparc change D130273.
Close https://github.com/llvm/llvm-project/issues/57587
Reviewed By: #powerpc, nemanjai
Differential Revision: https://reviews.llvm.org/D145141
Arthur Eubanks [Fri, 3 Mar 2023 00:19:23 +0000 (16:19 -0800)]
[Pipeline] Adjust PostOrderFunctionAttrs placement in simplification pipeline
We can infer more attribute information once functions are fully
simplified, so move the PostOrderFunctionAttrs pass after the function
simplification pipeline. However, just doing this can impact
simplification of recursive functions since function simplification
takes advantage of function attributes of callees (some LLVM tests are
actually impacted by this), so keep a copy of PostOrderFunctionAttrs
before the function simplification pipeline that only runs on recursive
functions.
For example, this fixes the small regression noticed in https://reviews.llvm.org/D128830.
This requires some restructuring of the CGSCC NoRerun feature. We need
to cache the ShouldNotRunFunctionPassesAnalysis analysis after the
simplification is done, which now is after the second
PostOrderFunctionAttrs run, rather than after the function
simplification pipeline.
Compile time impact:
https://llvm-compile-time-tracker.com/compare.php?from=
33cf40122279342b50f92a3a53f5c185390b6018&to=
1bb2a07875634e508a6bdf2ca1b130f55510f060&stat=instructions:u
Compile time increase from unconditionally running the first PostOrderFunctionAttrs:
https://llvm-compile-time-tracker.com/compare.php?from=
1bb2a07875634e508a6bdf2ca1b130f55510f060&to=
f4f87e89cc7a35c64e3a103a8036192a84ae002b&stat=instructions:u
Reviewed By: nikic
Differential Revision: https://reviews.llvm.org/D145210
Arthur Eubanks [Mon, 6 Mar 2023 17:00:33 +0000 (09:00 -0800)]
[SROA] Make order of analysis fetching more predictable
For pipeline tests.
Dhruv Chawla [Mon, 6 Mar 2023 16:16:16 +0000 (08:16 -0800)]
[clang][alias|ifunc]: Add a diagnostic for mangled names
When an alias or ifunc attribute refers to a function name that is
mangled, a diagnostic is emitted to suggest the mangled name as a
replacement for the given function name for every matching name in the
current TU.
Fixes #59164
Differential Revision: https://reviews.llvm.org/D143803
Valentin Clement [Mon, 6 Mar 2023 16:54:29 +0000 (17:54 +0100)]
[flang] Do not query type_desc for unlimited polymoprhic entities in move_alloc
In D144997, the dynamic type of polymorphic entities is reset to the declared
type when the FROM is deallocated. To do this, the declared type was passed as
a fir.type_desc op. For unlimited polymorphic entities, this should just be a
null pointer.
Reviewed By: PeteSteinfeld
Differential Revision: https://reviews.llvm.org/D145380
Valentin Clement [Mon, 6 Mar 2023 16:45:50 +0000 (17:45 +0100)]
[flang] Avoid double cleanup when the result is cleaned up by the Destroy function
The Destroy runtime function does free the memory so do not do it
inlined when we use Destroy. This avoid a double free execution error.
Reviewed By: PeteSteinfeld
Differential Revision: https://reviews.llvm.org/D145372
Nilay Vaish [Tue, 14 Feb 2023 08:01:59 +0000 (00:01 -0800)]
Checked that complexity of std::sort_heap is 2N log(N) comparisons
https://wg21.link/LWG2444 updated the comparison complexity of
std:sort_heap to be at most 2N log (N) where N == last - first. In the
current implementation, we invoke __pop_heap exactly N-1 times. In each
call to __pop_heap, we first go down the heap from first to possibly
last in the function __floyd_sift_down. Then, we possibly go back up in
the function __sift_up.
In the function __floyd_sift_down, there is loop in which one comparison
is made in each iteration. The loop runs till __child becomes greater
than (__len - 2) / 2. __child starts at 0 and it is at least set to 2 *
__child + 1 on each iteration. Thus, after k iterations, __child will
be at least 2^k - 1. After log(N) iterations, __child >= 2^(log(N)) -
1 = N - 1 > (__len - 2) / 2. This means that the while loop in the
function __floyd_sift_down would perform at most log(N) comparisons on
each invocation.
In the function __sift_up, there is one comparison made that will almost
always occur. After that there is a do-while loop. The comparison
function is invoked once in each iteration. In the worst case, the loop
will run till __len goes down to zero. It can start from (N-3)/2. In
each iteration, __len goes down to (__len-1) / 2. After k iterations,
__len will be at most (N - 2^(k+1) -1) / 2^(k+1). Thus, __len will
become when (N-2^(k+1)-1) < 2^(k+1) i.e. N < 2^(k+2) + 1. This means
at most log(N) - 1 iterations for the loop. So in total at most log(N)
comparison will be performed in __sift_up.
So overall for each iteration of the loop in __pop_heap, there will at
most 2 log(N) comparisons. So, the total number of comparisons is
at most 2 N log(N).
We also updated the test sort.heap/complexity.pass.cpp to test for the
number of operations.
Differential Revision: https://reviews.llvm.org/D144538
Goran Flegar [Mon, 6 Mar 2023 16:24:26 +0000 (17:24 +0100)]
[bazel] Fix build after 28d04c5
Chia-hung Duan [Fri, 3 Mar 2023 21:43:29 +0000 (21:43 +0000)]
[scudo] Temporarily disable GetRssFromBuffer test
This is a flaky test and may not test the thing it expected to verify.
E.g., it doesn't dirty the pages so the memory usage may not be reflected
on the RSS.
Reviewed By: cferris
Differential Revision: https://reviews.llvm.org/D145126
Chia-hung Duan [Fri, 3 Mar 2023 19:21:11 +0000 (19:21 +0000)]
[scudo] Mitigate page releasing thrashing
We have the heuristic to determine the threshold of doing page
releasing for smaller size classes. However, in a case that the
memory usage is bouncing between that threshold may result in
frequent try of page releasing but not returning much memory.
This CL add another heuristic to mitigate this problem by increasing
the minimum pages that potentially can be released. Note that this
heuristic is only applied on SizeClassAllocator64. SizeClassAllocator32
has a smaller group size so the overhead is smaller than 64-bit
platform.
Differential Revision: https://reviews.llvm.org/D144768
Chia-hung Duan [Fri, 3 Mar 2023 01:45:34 +0000 (01:45 +0000)]
Reland D144920 "[scudo] Only prepare PageMap entry for partial region
This reverts commit
daaef4c49954cb04ea1831615e0876865a29a08a.
Differential Revision: https://reviews.llvm.org/D144920
Marco Elver [Mon, 6 Mar 2023 16:15:53 +0000 (17:15 +0100)]
[SelectionDAG] Optimize copyExtraInfo deep copy
It turns out that there are relatively trivial, albeit rare, cases that
require a MaxDepth of more than 16 (see added test). However, we want to
avoid having to rely on a large fixed MaxDepth.
Since these cases are relatively rare, apply the following strategy:
1. Start with a low MaxDepth of 16 - if the entry node was not
reached, we can return (the common case).
2. If the entry node was reached, exponentially increase MaxDepth up
to some large limit that should cover all cases and guard against
stack exhaustion.
This retains the better performance with a low MaxDepth in the common
case, and in complex cases backs off and retries. On a whole, this is
preferable vs. starting with a large MaxDepth which would unnecessarily
penalize the common case where a low MaxDepth is sufficient.
Reviewed By: dvyukov
Differential Revision: https://reviews.llvm.org/D145386
Jakub Kuderski [Mon, 6 Mar 2023 16:10:59 +0000 (11:10 -0500)]
[ADT] Clean up zip iterators. NFC.
* Use inheriting constructors declarations to avoid introducing the
`Base` typedef and duplicate constructor definitions. This should make
things cleaner, especially since `zip_common` also exposes a `Base`
typedef.
* Drop unnecessary template parameters.
* Avoid double negation in `zip_shortest`'s `operator==` and rename the
comparison function for better readability.
Reviewed By: zero9178
Differential Revision: https://reviews.llvm.org/D145332
Simon Pilgrim [Mon, 6 Mar 2023 16:13:58 +0000 (16:13 +0000)]
[X86] combineBitcastvxi1/checkBitcastSrcVectorSize - sign-extend vXi1 allones vselect operands
Minor fix to Issue #61104
Simon Pilgrim [Mon, 6 Mar 2023 16:09:05 +0000 (16:09 +0000)]
[X86] Add Issue #61104 test case
Shows the failure of combineBitcastvxi1 to sign-extend a vXi1 allones vselect operand
There's a number of other problems in Issue #61104 still to address, but this one has an easy quick fix
Siva Chandra Reddy [Mon, 6 Mar 2023 08:48:57 +0000 (08:48 +0000)]
[libc] Add arm 32 FEnvImpl.
Reviewed By: lntue
Differential Revision: https://reviews.llvm.org/D145347
Guillaume Chatelet [Mon, 6 Mar 2023 14:13:07 +0000 (14:13 +0000)]
Fix SafeIntIterator reference type
We explicitly state that the `reference` type for Sequence iterator is a `value_type`.
Since the iterator is a lazy generator, it cannot point to any memory and so it cannot have a reference type.
Fixes https://github.com/llvm/llvm-project/issues/61122
Differential Revision: https://reviews.llvm.org/D145373
Zequan Wu [Wed, 1 Mar 2023 21:28:35 +0000 (16:28 -0500)]
[LLDB][NativePDB] Check string table in PDB files.
Usually PDB files have a string table (aka: Named Stream "/names" ). PDB for
some windows system libraries might not have that. This adds the check for it to
avoid crash in the absence of string table.
Reviewed By: labath
Differential Revision: https://reviews.llvm.org/D145115
Mehdi Amini [Mon, 23 Jan 2023 00:32:07 +0000 (00:32 +0000)]
Rename DebugAction to tracing::Action and move related code from lib/Support to lib/IR and lib/Debug
This is a preparation for adding support for more infrastructure around the concept
of Action and make tracing Action more of a first class concept.
The doc will be updated later in a subsequent revision after the changes are
completed.
Action belongs to IR because of circular dependency: Actions are dispatched through
the MLIRContext but Action will learn to encapsulate IR construct.
Differential Revision: https://reviews.llvm.org/D144809
Paul Scoropan [Wed, 1 Mar 2023 17:50:45 +0000 (12:50 -0500)]
[Flang] [PowerPC} Implement the floating-point conversion PowerPC intrinsics
All the fc* floating point conversion PowerPC intrinsics are simply lowered to their LLVM IR intrinsic counterparts and do not require any additional error checking.
Reviewed By: klausler, jeanPerier
Differential Revision: https://reviews.llvm.org/D145080
Mehdi Amini [Tue, 18 Oct 2022 23:03:48 +0000 (23:03 +0000)]
Change the DebugAction paradigm to delegate the control to the handler
At the moment, we invoke `shouldExecute()` that way:
```
if (manager.shouldExecute<DebugAction>(currentOp) {
// apply a transformation
…
}
```
In this sequence, the manager isn’t involved in the actual execution
of the action and can’t develop rich instrumentations. Instead the API
could let the control to the handler itself:
```
// Execute the action under the control of the manager
manager.execute<DebugAction>(currentOp, [&]() {
// apply the transformation in this callback
…
});
```
This inversion of control (by injecting a callback) allows handlers to
implement potentially new interesting features: for example, snapshot
the IR before and after the action, or record an action execution time.
More importantly, it will allow to capture the nesting execution of
actions.
On the other side: handlers receives now a DebugAction object that wraps
generic information (tag and description especially) as well as
action-specific data.
Finally, the DebugActionManager is now enabled in release builds as
well.
Differential Revision: https://reviews.llvm.org/D144808
Simon Pilgrim [Mon, 6 Mar 2023 14:45:49 +0000 (14:45 +0000)]
[X86] vector-shuffle-avx512.ll - update to use attributes instead of hard coded cpu targets
Similar to most of the other vector-shuffle-* test files
Avoids some codegen deltas due to upcoming changes for no-costs domain switching between shuffle types
Louis Dionne [Thu, 2 Mar 2023 22:28:13 +0000 (17:28 -0500)]
[libc++] Add support for .compile.pass.mm and .link.pass.mm tests
Differential Revision: https://reviews.llvm.org/D145193
David Truby [Mon, 27 Feb 2023 15:37:08 +0000 (15:37 +0000)]
[flang] Implement ieee_is_normal
This patch adds an implementation of ieee_is_normal using a call
to llvm.is.fpclass.
Depends on D144649
Differential Revision: https://reviews.llvm.org/D144966
Leandro Lupori [Fri, 24 Feb 2023 11:57:50 +0000 (11:57 +0000)]
[flang] Fix lowering of optional char proc args
Optional character function arguments were not being lowered
properly. As they are passed as a tuple, containing the (boxed)
function address and the character length, it is not possible for
fir.absent to handle it directly. Instead, a tuple needs to be
created and filled with an absent function address and a dummy
character length.
Fixes #60225
Reviewed By: jeanPerier
Differential Revision: https://reviews.llvm.org/D144743
Jake Egan [Mon, 6 Mar 2023 14:22:05 +0000 (09:22 -0500)]
[NFC] Disable test temporarily to investigate why it's failing on AIX
Test failing due to D145098. Disabling the test to get the AIX bot
green while investigating.
Mehdi Amini [Sat, 25 Feb 2023 04:16:37 +0000 (21:16 -0700)]
Expose a convenient registerCLOptions() for MlirOptMainConfig
This allows for downstream *-opt tools to stay always aligned with the options
exposed by mlir-opt.
It aligns the "generic" options with the more "components" ones like the
pass manager options or the context options.
Differential Revision: https://reviews.llvm.org/D144782
Paul Walker [Thu, 2 Mar 2023 14:10:11 +0000 (14:10 +0000)]
[InstCombine] Implement "A & (~A | B) --> A & B" like transforms for boolean based selects.
Alive2 links for "A & (~A | B) --> A & B":
https://alive2.llvm.org/ce/z/oKiodu (scalar)
https://alive2.llvm.org/ce/z/8yn8GL (vector)
Alive2 links for "A | (~A & B) --> A | B"
https://alive2.llvm.org/ce/z/v5GEKu (scalar)
https://alive2.llvm.org/ce/z/wvtJsj (vector)
NOTE: The commutative variants of these transforms, for example:
"(~A | B) & A --> A & B"
are already handled by simplifying the underlying selects to
normal logical operations due to that combination having simpler
poison semantics.
Differential Revision: https://reviews.llvm.org/D145157
David Stenberg [Mon, 6 Mar 2023 10:15:53 +0000 (11:15 +0100)]
[DebugInfo] Merge partially matching chains of inlined locations
For example, if you have a chain of inlined funtions like this:
1 #include <stdlib.h>
2 int g1 = 4, g2 = 6;
3
4 static inline void bar(int q) {
5 if (q > 5)
6 abort();
7 }
8
9 static inline void foo(int q) {
10 bar(q);
11 }
12
13 int main() {
14 foo(g1);
15 foo(g2);
16 return 0;
17 }
with optimizations you could end up with a single abort call for the two
inlined instances of foo(). When merging the locations for those inlined
instances you would previously end up with a 0:0 location in main().
Leaving out that inlined chain from the location for the abort call
could make troubleshooting difficult in some cases.
This patch changes DILocation::getMergedLocation() to try to handle such
cases. The function is rewritten to first find a common starting point
for the two locations (same subprogram and inlined-at location), and
then in reverse traverses the inlined-at chain looking for matches in
each subprogram. For each subprogram, the merge function will find the
nearest common scope for the two locations, and matching line and
column (or set them to 0 if not matching).
In the example above, you will for the abort call get a location in
bar() at 6:5, inlined in foo() at 10:3, inlined in main() at 0:0 (since
the two inlined functions are on different lines, but in the same
scope).
I have not seen anything in the DWARF standard that would disallow
inlining a non-zero location at 0:0 in the inlined-at function, and both
LLDB and GDB seem to accept these locations (with D142552 needed for
LLDB to handle cases where the file, line and column number are all 0).
One incompatibility with GDB is that it seems to ignore 0-line locations
in some cases, but I am not aware of any specific issue that this patch
produces related to that.
With x86-64 LLDB (trunk) you previously got:
frame #0: 0x00007ffff7a44930 libc.so.6`abort
frame #1: 0x00005555555546ec a.out`main at merge.c:0
and will now get:
frame #0: 0x[...] libc.so.6`abort
frame #1: 0x[...] a.out`main [inlined] bar(q=<unavailable>) at merge.c:6:5
frame #2: 0x[...] a.out`main [inlined] foo(q=<unavailable>) at merge.c:10:3
frame #3: 0x[...] a.out`main at merge.c:0
and with x86-64 GDB (11.1) you will get:
(gdb) bt
#0 0x00007ffff7a44930 in abort () from /lib64/libc.so.6
#1 0x00005555555546ec in bar (q=<optimized out>) at merge.c:6
#2 foo (q=<optimized out>) at merge.c:10
#3 0x00005555555546ec in main ()
Reviewed By: aprantl, dblaikie
Differential Revision: https://reviews.llvm.org/D142556
David Stenberg [Mon, 6 Mar 2023 10:18:24 +0000 (11:18 +0100)]
[lldb] Make GetDIENamesAndRanges() allow 0-valued decl and call lines
In an upcoming patch, D142556, Clang is proposed to be changed to emit
line locations that are inlined at line 0. This clashed with the behavior of
GetDIENamesAndRanges() which used 0 as a default value to determine if
file, line or column numbers had been set. Users of that function then
checked for any non-0 values when setting up the call site:
if (call_file != 0 || call_line != 0 || call_column != 0)
[...]
which did not work with the Clang change since all three values then
could be 0.
This changes the function to use std::optional to catch non-set values
instead.
Reviewed By: clayborg
Differential Revision: https://reviews.llvm.org/D142552
Valentin Clement [Mon, 6 Mar 2023 13:09:38 +0000 (14:09 +0100)]
[flang] Handle parent component in select type
In select type construct the associating entity in a TYPE IS
type guard statement is obtained with a fir.convert. Update the code
for the parent component to support fir.convert defining op
as well.
Reviewed By: jeanPerier
Differential Revision: https://reviews.llvm.org/D145367
Haojian Wu [Mon, 6 Mar 2023 11:06:44 +0000 (12:06 +0100)]
[Tooling/Inclusion] Add missing index_sequence symbols.
Fixes https://github.com/llvm/llvm-project/issues/61026
Differential Revision: https://reviews.llvm.org/D145365
Jean Perier [Mon, 6 Mar 2023 13:00:26 +0000 (14:00 +0100)]
[flang][hlfir] Lower intrinsic module procedures to HLFIR
Intrinsic module procedures are a bit different from intrinsic
procedures: they are defined in intrinsic module files, but their
signature and representation in semantics is the same as user
procedures.
The code to lower them in lowering (when they are not implemented in
Fortran) is the same as for intrinsic procedures
(Optimizer/Builder/IntrinsicCall.cpp).
The dispatching in in HLFIR procedure reference lowering must be
slightly modified so that these evaluate::ProcRef that have a
semantics::Symbol instead of an evaluate::SpecificIntrinsic can
be dispatched as evaluate::SpecificIntrinsic:
- move isIntrinsicModuleProcedure to detect them
- in the helpers dealing with intrinsics, make evaluate::SpecificIntrinsic
a pointer argument that can be null for intrinsic module procedures.
- add getProcedureName() to call context to avoid relying on the
evaluate::SpecificIntrinsic when it is not know to be null.
Differential Revision: https://reviews.llvm.org/D145360
Jean Perier [Mon, 6 Mar 2023 12:59:15 +0000 (13:59 +0100)]
[flang][hlfir] use new runtime for whole allocatable assignment
- use AssignExplicitLengthCharacter for assignment to whole allocatable
character with assumed or explicit length.
- use AssignPolymorphic for assignment to whole allocatable
polymorphic.
Differential Revision: https://reviews.llvm.org/D145363
Matthias Springer [Mon, 6 Mar 2023 11:38:18 +0000 (12:38 +0100)]
[mlir][IR] Clean up mergeBlockBefore and mergeBlocks
* `RewriterBase::mergeBlocks` is simplified: it is implemented in terms of `mergeBlockBefore`.
* The signature of `mergeBlockBefore` is consistent with other API (such as `inlineRegionBefore`): an overload for a `Block::iterator` is added.
* Additional safety checks are added to `mergeBlockBefore`: detect cases where the resulting IR could be invalid (no more `dropAllUses`) or partly unreachable (likely a case of incorrect API usage).
* Rename `mergeBlockBefore` to `inlineBlockBefore`.
Differential Revision: https://reviews.llvm.org/D144969
pvanhout [Mon, 6 Mar 2023 11:28:14 +0000 (12:28 +0100)]
[AMDGPU] Use UniformityAnalysis in LateCodeGenPrepare
Reviewed By: foad
Differential Revision: https://reviews.llvm.org/D145366
Hsiangkai Wang [Mon, 16 Jan 2023 04:21:51 +0000 (04:21 +0000)]
[NFC][AArch64] Use 'i' to encode the offset form of load/store.
STG, STZG, ST2G, STZ2G are the exceptions to append 'Offset' to name the
offset format of load/store instructions. All other load/store
instructions use 'i' as the appendix. If there is no special reason to
do so, we should make the naming consistent.
Differential Revision: https://reviews.llvm.org/D141819
pvanhout [Mon, 6 Mar 2023 08:19:57 +0000 (09:19 +0100)]
[AMDGPU] Use UniformityAnalysis in CodeGenPrepare
A little extra change was needed in UA because it didn't consider
InvokeInst and it made call-constexpr.ll assert.
Reviewed By: sameerds, arsenm
Differential Revision: https://reviews.llvm.org/D145358
Haojian Wu [Mon, 6 Mar 2023 10:45:44 +0000 (11:45 +0100)]
[include-cleaner] Fix a crash on non-identifier-name symbols.
Differential Revision: https://reviews.llvm.org/D145364
Nikita Popov [Mon, 6 Mar 2023 12:12:55 +0000 (13:12 +0100)]
[IR] Remove ConstantExpr::getUMin() (NFC)
This is part of select constant expression removal. As there is
only a single place where this is used, just expand it to explicit
constant folding calls.
(Normally we'd just use the IRBuilder here, but this isn't possible
due to mergeUndefsWith use).
Luís Marques [Mon, 6 Mar 2023 12:08:28 +0000 (13:08 +0100)]
[CMake] Enforce LLVM_ENABLE_UNWIND_TABLES
In D61448 the cmake option `LLVM_ENABLE_UNWIND_TABLES` was added.
Despite the name suggesting that the option enables unwind tables, that
patch only uses it to disable them. That makes a difference for
architectures where unwind tables aren't enabled by default. The lack of
unwind tables impacts backtraces and the current handling of the option
doesn't allow enabling them. This patch makes an ON value of
`LLVM_ENABLE_UNWIND_TABLES` actually enable unwind tables.
Differential Revision: https://reviews.llvm.org/D144178
Jay Foad [Mon, 6 Mar 2023 11:52:56 +0000 (11:52 +0000)]
[AMDGPU] Restore temporal divergence in test
The loop in this test was supposed to have temporal divergence but this
was broken by r367221. Fix it.
Archibald Elliott [Thu, 2 Mar 2023 14:46:40 +0000 (14:46 +0000)]
[ARM] Fix Chain/Glue Bug in PerformVMOVhrCombine
In this optimisation, the Chain and Glue from the original CopyFromReg
was being lost by this optimisation, which resulted in miscompiles.
This fix just ensures that the input chains are correctly updated, and
that any any users are also updated with the new chain from the new
CopyFromReg.
Fixes #60510.
Differential Revision: https://reviews.llvm.org/D143713
Archibald Elliott [Thu, 2 Mar 2023 14:39:41 +0000 (14:39 +0000)]
[ARM] Pre-Commit Tests for PR60510
Differential Revision: https://reviews.llvm.org/D143712
Archibald Elliott [Thu, 2 Mar 2023 13:44:23 +0000 (13:44 +0000)]
[ARM] Fix Crash in 't'/'w' handling without fp16/bf16
After https://reviews.llvm.org/rGff4027d152d0 and
https://reviews.llvm.org/rG7d15212b8c0c we saw crashes in SelectionDAG
when trying to use these constraints when you don't have the fp16 or
bf16 extensions.
However, it is still possible to move 16-bit floating point values into
the right place in S registers with a normal `vmov`, even if we don't
have fp16 instructions we can use within the inline assembly string.
This patch therefore fixes the crash.
I think the reason we weren't getting this crash before is because I
think the __fp16 and __bf16 types got an error diagnostic in the Clang
frontend when you didn't have the right architectural extensions to use
them. This restriction was recently relaxed.
The approach for bf16 needs a bit more explanation. Exactly how BF16 is
legalized was changed in rGb769eb02b526e3966847351e15d283514c2ec767 -
effectively, whether you have the right instructions to get a bf16 value
into/out of a S register with MoveTo/FromHPR depends on hasFullFP16, but
whether you use a HPR for a value of type MVT::bf16 depends on hasBF16.
This is why the tests are not changed by `+bf16` vs `-bf16`, but I've
left both sets of RUN lines in case this changes in the future.
Test Changes:
- Added more testing for testing inline asm (the core part)
- fp16-promote.ll and pr47454.ll show improvements where unnecessary
fp16-fp32 up/down-casts are no longer emitted. This results in fewer
libcalls where those casts would be done with a libcall.
- aes-erratum-fix.ll is fairly noisy, and I need to revisit this test so
that the IR is more minimal than it is right now, because most of the
changes in this commit do not relate to what AES is actually trying to
verify.
Differential Revision: https://reviews.llvm.org/D143711
Adrian Kuegel [Mon, 6 Mar 2023 11:42:03 +0000 (12:42 +0100)]
[mlir] Apply ClangTidy readability finding (NFC)
pvanhout [Mon, 6 Mar 2023 08:26:35 +0000 (09:26 +0100)]
[AMDGPU] Use UniformityAnalysis in RewriteUndefsForPHI
Reviewed By: foad
Differential Revision: https://reviews.llvm.org/D145359
usama hameed [Mon, 6 Mar 2023 11:08:26 +0000 (16:08 +0500)]
[Sanitizers] Error out for -static-libsan on darwin
Differential Revision: https://reviews.llvm.org/D144672
Florian Hahn [Mon, 6 Mar 2023 11:03:27 +0000 (12:03 +0100)]
[GlobalOpt] Add SRA test with constant expr GEPs without inbounds.
Another test for D144476.
Simon Pilgrim [Mon, 6 Mar 2023 11:01:45 +0000 (11:01 +0000)]
ExternalFunctions.cpp - fix "unknown pragma 'clang'" MSVC warning. NFCI.
MarcoFalke [Sun, 5 Feb 2023 16:14:22 +0000 (17:14 +0100)]
clang-tidy: Count template constructors in modernize-use-default-member-init
Differential Revision: https://reviews.llvm.org/D143375
Matt Arsenault [Thu, 26 Jan 2023 17:20:12 +0000 (13:20 -0400)]
AMDGPU: Combine down fcopysign f64 magnitude
Copy through the low bits and only apply an f32
copysign to the high half. This is effectively
what we do for codegen anyway, but this provides
some combine benefits. The cases involving constants
show some small improvements.
https://reviews.llvm.org/D142682
Paulo Matos [Mon, 6 Mar 2023 09:51:14 +0000 (10:51 +0100)]
Revert "[Docs] Add my Office Hours"
This reverts commit
b293de988059cac25c4ad84371be09107de7bbc4.
Florian Hahn [Mon, 6 Mar 2023 09:50:34 +0000 (10:50 +0100)]
[GlobalOpt] Add tests that only stores initializer, split test file.
Add an additional tests that stores the initializer, but the global
doesn't have a zeroinitializer. Also separate out the tests for storing
initializers.
Add extra tests for D144476.
Haojian Wu [Mon, 6 Mar 2023 09:33:54 +0000 (10:33 +0100)]
[include-fixer] Add the missing optional header to the STL header list.
Matthias Springer [Mon, 6 Mar 2023 08:24:39 +0000 (09:24 +0100)]
[mlir][IR] Trigger notifyOperationModified for replacements
Each user of the original value is modified in-place. Therefore, the corresponding notification should be triggered.
Also fixes a bug where `RewriterBase::mergeBlocks` did not notify the GreedyPatternRewriteDriver when replacing uses of block arguments. This function does not trigger "operation replaced" notifications, so the GreedyPatternRewriteDriver was not made aware of such IR changes.
Differential Revision: https://reviews.llvm.org/D144549
Nikita Popov [Fri, 3 Mar 2023 15:22:41 +0000 (16:22 +0100)]
[LowerTypeTests] Avoid creation of select constant expression
LowerTypeTests replaces weak declarations with an icmp+select
constant expressions. As this is not a relocatable expression,
it additionally promotes initializers using it to global ctors.
As part of https://discourse.llvm.org/t/rfc-remove-most-constant-expressions/63179,
I would like to remove the select constant expression, of which LTT
is now the last user. This is a bit tricky, because we now need to
replace a constant with an instruction, which might require
converting intermediate constant expression users to instructions as
well.
We do this using the convertUsersOfConstantsToInstructions() helper.
However, it needs to be slightly extended to also support expansion
of ConstantAggregates. These are important in this context, because
the promotion of initializers to global ctors will produce stores
of such aggregates.
Differential Revision: https://reviews.llvm.org/D145247
Max Kazantsev [Mon, 6 Mar 2023 08:13:55 +0000 (15:13 +0700)]
[SimpleLoopUnswtich] Support zext when injecting invariant conditions
This patch handles the following case: turn
```
if (x <u Invariant1) {
if (zext(x) <u Invariant2) {
...
}
}
```
into
```
if (x <u Invariant1) {
if (zext(Invariant1) <=u Invariant2) { // Unswitch here
// No check needed
} else {
if (zext(x) <u Invariant2) {
...
}
}
}
```
Differential Revision: https://reviews.llvm.org/D138015
Reviewed By: skatkov
Mariya Podchishchaeva [Mon, 6 Mar 2023 08:25:57 +0000 (03:25 -0500)]
[clang] Fix aggregate initialization inside lambda constexpr
Constant evaluator only considered access to `this` pointer to be
possible if `this` poitners was captured. However `this` can also appear if
there was a default member initializer.
Fixes https://github.com/llvm/llvm-project/issues/60936
Reviewed By: shafik
Differential Revision: https://reviews.llvm.org/D144866
Valentin Clement [Mon, 6 Mar 2023 08:35:36 +0000 (09:35 +0100)]
[flang] Use AssignPolymorphic when LHS is polymorphic
Make use of the new runtime entry point for assignment to
LHS allocatable polymorphic.
Reviewed By: jeanPerier
Differential Revision: https://reviews.llvm.org/D145324
Kai Luo [Mon, 6 Mar 2023 08:01:24 +0000 (16:01 +0800)]
Reland [AIX][BigArchive] Treat the archive is empty if the first child member offset is zero
If the archive contains free list and contains no member file, the buffer length doesn't equal to length of the header.
Reviewed By: Esme, DiggerLin, #powerpc
Differential Revision: https://reviews.llvm.org/D138986
Balázs Kéri [Mon, 6 Mar 2023 07:55:19 +0000 (08:55 +0100)]
[clang][ASTImporter] Add VaList declaration to lookup table.
The declaration of __builtin_va_list seems to be handled specially
by ASTContext and/or Sema. The normal AST traversal probably can
not find it, therefore it is not added to ASTImporterLookupTable.
If it is not added, errors can occur because a duplicated
VaList declaration is created at import. To fix the problem the
VaList declaration is added manually to ASTImporterLookupTable
at construction.
In special cases this declaration is inside a "invisible" 'std'
namespace that behaves the same way. This namespace must be added
to the table too.
Reviewed By: vabridgers, donat.nagy
Differential Revision: https://reviews.llvm.org/D144273
Siva Chandra [Mon, 6 Mar 2023 08:24:16 +0000 (00:24 -0800)]
[libc][Obvious] Add back CMake logic which was mistakenly deleted earlier.
Matthias Springer [Mon, 6 Mar 2023 08:11:42 +0000 (09:11 +0100)]
[mlir][IR][NFC] Move `walk` definitions to header file
This allows users to provide custom `Iterator` templates. A new iterator will be added in a subsequent change.
Also rename `makeRange` to `makeIterable` and add a test case for the reverse iterator.
Differential Revision: https://reviews.llvm.org/D144887
Max Kazantsev [Mon, 6 Mar 2023 08:11:56 +0000 (15:11 +0700)]
[NFC] Fix typo in comment
Matthias Springer [Fri, 3 Mar 2023 16:56:39 +0000 (17:56 +0100)]
[mlir][Interfaces] ReifyRankedShapedTypeOpInterface returns OpFoldResults
`reifyResultShapes` now returns `OpFoldResult`s instead of `Value`s. This is often more efficient because many transformations immediately attempt to extract a constant from the reified values.
Differential Revision: https://reviews.llvm.org/D145250
Siva Chandra Reddy [Sat, 4 Mar 2023 05:35:45 +0000 (05:35 +0000)]
[libc] Simplify integration tests by eliminating the artificial sysroot.
The test binaries are built like any other executable but with two
additional linker options -static and -nostdlib.
Reviewed By: jhuber6
Differential Revision: https://reviews.llvm.org/D145298
Muhammad Omair Javaid [Mon, 6 Mar 2023 07:25:52 +0000 (11:25 +0400)]
[LLVM] Remove XFAIL from merge-equivalent-ranges.ll
This patch removes XFAIL decorator from merge-equivalent-ranges.ll
test.
Merge equilant ranges is passing on aarch64-windows-msvc buildbot
since: https://lab.llvm.org/buildbot/#/builders/120/builds/4291
Kazu Hirata [Mon, 6 Mar 2023 06:48:28 +0000 (22:48 -0800)]
[APInt] Deprecate several functions
This patch deprecates:
- those functions that have been soft-deprecated
- countPopulation
Note that I've already migrated away from all known uses of these
functions.
Differential Revision: https://reviews.llvm.org/D144423
Chuanqi Xu [Mon, 6 Mar 2023 06:39:27 +0000 (14:39 +0800)]
[NFC] Add an invalid test case for C++20 Modules
Address https://github.com/llvm/llvm-project/issues/61150.
The test is intended to show the polluted operator&& will affect the ODR
checking and the ODR checking here is correct.
Carl Ritson [Mon, 6 Mar 2023 02:36:01 +0000 (11:36 +0900)]
[ValueMapper] Preserve poison types during value mapping
Poison needs to be treated directly during type remap otherwise
it will be considered an instance of undef.
Reviewed By: dexonsmith
Differential Revision: https://reviews.llvm.org/D145317
Sameer Sahasrabuddhe [Mon, 6 Mar 2023 04:56:01 +0000 (10:26 +0530)]
[llvm] [NFC] fix comments describing GenericSSAContext