In D92743#2440881, @aeubanks wrote:

Also, I have run the tests with enable-new-pm=true. However, there are 36 failures which are already failing with new-PM without my change (had to build both with and without my change to confirm this). Is there some buildbot that tracks the NewPM option? It will make it easier to catch if any testcases regress...

I'm working on reducing it to 0 so that we can have a bot that checks if it regresses.

Great, thanks!

missed one review comment: move DL initialization to runImpl.

addressed review comments

In D92743#2438777, @aeubanks wrote:

can you remove this from the list in https://github.com/llvm/llvm-project/blob/6e614b0c7ed3a9a66428f342bf2a4b3700525395/llvm/tools/opt/opt.cpp#L463 and make sure that no check-llvm tests regress when -enable-new-pm is turned on by default? (I should rename that function)

Yes, pls rename the function since it actually represents which passes are not yet ported to NewPM.
Also, I have run the tests with enable-new-pm=true. However, there are 36 failures which are already failing with new-PM without my change (had to build both with and without my change to confirm this). Is there some buildbot that tracks the NewPM option? It will make it easier to catch if any testcases regress...

In D92743#2436311, @skatkov wrote:

Please consider separate renaming to Legacy to NFC patch.

ping.

missed adding new header file to diff.

rebased over landed NFCs.

Nice catch! LGTM from me. One comment inline. Pls see if @fhahn has any comments as well?

addressed review comments

missed adding new file into commit.

Just recording here (previous discussion was here D90742) :
our internal buildbots at Azul has failed because of an older assembler. We’ve taken in all commits/reverts/relands w.r.t this change upto Nov 4th. I have reverted the change rG8383fddc4fa9 downstream and confirmed the build passes.

We use the GNU assembler and it is configured for 64 bit machines. Here's the details from one of the machines:

as --version
GNU assembler version 2.20.51.0.2-5.47.el6_9.1 20100205
Copyright 2009 Free Software Foundation, Inc.
This program is free software; you may redistribute it under the terms of
the GNU General Public License version 3 or later.
This program has absolutely no warranty.
This assembler was configured for a target of `x86_64-redhat-linux'

Also, note that I tagged this against the incorrect review. The change causing the failures is https://reviews.llvm.org/D90592. I'm going to paste this there and we can continue discussion there.

Just a stylistic comment. You can have the InvariantCond as a struct with the fields: InvariantPred, InvariantLHS, InvariantRHS. I think this will make code more readable (for example, use the struct in ReplaceInvariantCond(ExitingBB, InvariantCond).

hi @courbet,
our internal buildbots at Azul has failed because of an older assembler. We’ve taken in all commits/reverts/relands w.r.t this change upto Nov 4th.

Hi @nikic, some comments below.

In D90688#2381609, @nikic wrote:

I've applied a couple of fixes to CaptureTracking, the main ones are: https://github.com/llvm/llvm-project/commit/d35366bccae0016418660337ce94e3d7d0ff391e is a potential correctness fix, https://github.com/llvm/llvm-project/commit/f63ab188c63be12871da75bfc5801a7fc752769b is a compile-time improvement.

Ah, I think your correctness fix is what Johannes was implying by the "multiple args captured" in a single call.

In D90688#2376444, @nikic wrote:

This change causes a large compile-time regression on some benchmarks: https://llvm-compile-time-tracker.com/compare.php?from=79d16764dd29aeddb7e6400e6b2d89d31653886c&to=15694fd6ad955c6a16b446a6324364111a49ae8b&stat=instructions

tramp3d-v4 is particularly badly affected, with a 25% instruction count regression in the ThinLTO configuration.

In D90688#2376333, @thakis wrote:

This seems to break tests: http://45.33.8.238/linux/32182/step_7.txt

In D90688#2371455, @jdoerfert wrote:

LGTM. Attributor does the same with an "optimistic" version of reachability via AAReachability. I guess that is why no test there changed.

Hi @kazu, just wanted to point out - We have seen multiple assertion failures in benchmarks downstream with this patch (or a related one built on this patch). Trying to revert this downstream shows there are dependent patches. Is this assertion seen and already fixed in trunk?

may revisit later.

In D87304#2319424, @jdoerfert wrote:

In D87304#2318780, @dantrushin wrote:

I wonder if align attribute is legal for vectors of pointers?
This is allowed:

define align 8 i32* @test_scalar(i32* %in) {
  ret i32* %in
}

but this is not:

define align 8 <4 x i32*> @test_vector(<4 x i32*> %in) {
  ret <4 x i32*> %in
}

Is it intentional behavior or just has been overlooked?

The way I read the lang ref this is intentional. Not to say one should not define what it means for vectors of pointers and then allow it. I feel align is not the only one missing for them though.
You want to give it a try?

addressed review comments, rebased and updated for AArch64 (this patch is NFC in behaviour for AArch64).

Hi Artur, just to explicitly state out:

But element atomic memcpy/memmove intrinsic calls might be generated by the optimizer, which is not aware of this coupling. If statepoints without deopt into are not allowed and we see a non-leaf memcpy/memmove without deopt state we treat it as a leaf copy and don't produce a statepoint

If a long running loop of loads and stores are converted to atomic memcpy (through loop idiom recognize for example) and we don't produce a statepoint - this will make the memcpy non GC parseable, which is erroneous. So, it is the responsibility of such runtimes to also introduce some mechanism to prevent long running loops from being converted to memcpys (such as having safepoint requests within the loop thereby preventing long running loops from being converted to memcpy: https://llvm.org/docs/Statepoints.html#id27).

addressed review comments. Bails out in case of overflow (added testcase for multiply overflow).

addressed review comments about splitting out patches. This patch handles complex addressing mode.

thanks for this Philip!

addressed review comments. Added more testcases (positive and countercases).

handle clang-tidy comment.

handles complex addressing mode using base and index operands. All test cases pass.
I plan to add more counter examples once the basic idea is agreed upon.

addressed review comments.

While working on a follow-up change, I realized we don't need to separate out whether we're handling simple or complex addressing mode based on whether we fault in zero page or not. Both are orthogonal issues. The reason I coupled them is because we still need a way to get the "total constant address" *if it exists* and make a distinction between when we succeeded to get one versus when there was no such constant address apart from the offset.

thanks Denis for your comments. I'll let others have a chance in review as well. Regarding broader audience today, implicit null checks works only with X86 (or rather that's what we test with). Also, none of the global APIs are changed, precisely because they are used in other parts of the code. Hence a new API is introduced and used currently only for implicit null checks. It is broad enough that we can reuse it in other passes if we wish to do so.

addressed review comments around using simpler form rather than isTied. Whitespace testcase changes avoided. NFC w.r.t. prev diff.

Code LGTM. quick glance at tests.

LGTM w/ comments inline.

LGTM. thanks for working on this! Apart from dropping all of the extra handling code in RS4GC and verifier (which itself is a really good reason for this support btw), I'm assuming this for optimizations which know about the deopt_op bundle (or gc_transition bundle) after relocations are made explicit? i.e., a general robustness patch.

thank you for the review!

addressed review comment about test case.

addressed review comments. Added unittest case.

Landed as bb308b020522420413c7d3f2989a88f2fc423c56.

Thanks Johannes. @fpetrogalli Francesco, I believe I've addressed your concern as well?

In D70107#2034194, @fpetrogalli wrote:

I don't see anything preventing this from being a function attribute as well.

HI @anna ,

apologies in advance for the late reply.

I don't think we want this. Imagine situation in which proto.h contains a scalar declaration foo marked with #pragma ompe declare simd. Suppose you include this header in 2 compilation units, one (sourceA.c) that can be compiled with -fopenmp-simd, and one (sourceB.c) that cannot be compiled with openmp - for any reason, for example because of some requirements on floating points computations. Then, you want to do some optimization that involves merging the two modules. The calls to foo in the IR generated from sourceB.c suddenly become vectorizable, which is wrong. So, overall, I think we should not attach this attribute to a function declaration.

I appreciate that what I described might be a remote possibility, but if we ever end up having to deal with it, it will be quite hard to fix.

Let me know if you have any question.

Kind regards,

Francesco

Hi @fpetrogalli,
Yes, but it should be orthogonal to that requirement. I think hiding the mangling behind a static function, while the demangling is exposed seems unintuitive. Any front-ends that need to attach the attribute will need this function exposed.