[llvm-dev] Is the correct behavior of getelementptr i192* for opt + llc -march=aarch64?

[Mehdi Amini via llvm-dev]

> On Nov 12, 2016, at 7:28 AM, Renato Golin via llvm-dev <llvm-dev at lists.llvm.org> wrote:
> 
> On 12 November 2016 at 03:42, MITSUNARI Shigeo via llvm-dev
> <llvm-dev at lists.llvm.org> wrote:
>> Thank you, I lost it, but I always use opt and llc on each host and do not mix them.
>> I'm sorry, I should have written %opt -O3 a.ll -o -|llc -O3 -o - (on x86-64 / aarch64).
> 
> Yes, that works if it's all native.
> 
> 
>> I see, but I want load192() in the previous mail should be inlined, but
>> only llc does not it if alwaysinline attribute is add.
> 
> Right, and that shows my argument very well: opt+llc != llc alone.
> 
> This time, it worked for you and you got the result you wanted. Next
> time, it may work against you and you'll be in the situation where you
> don't know if you run opt or not beforehand, depending on the case, or
> how many times you'll run opt.
> 
> I recommend you identify why opt is making a difference and submit a bug report.\
> 
> In theory, opt will pass the same passes in the same order as llc

I don’t believe there is any bug: opt is the *optimizer* and llc the *codegenerator*.

The behavior observed is absolutely expected.

— 
Mehdi


> (give or take a few things), so this falls into two scenarios:
> 
> 1. Some pass *after* inlining is reducing the threshold of the
> function you want to inline, so it only inlines on the second pass.
> 
> To see if this is the case, try to run opt twice on the IR (opt | opt)
> and see if the function is inlined the second time. If it is, then the
> "fix" would be working around the heuristics, or fiddling with your
> function to understand and correct the problem.
> 
> Using --print-after-all will give you an idea which pass is
> responsible for the simplification (hint: check for the state of IR
> just before the inlining phase on both runs, then trace back "who did
> it" when it worked).
> 
> 2. Opt and llc are not passing the same passes in the same order.
> 
> With the --print-after-all results from the investigation above, you
> can try to re-order the passes via opt and see, if you run in the same
> order as llc, you get only the out-of-line function.
> 
> If this is the case, then changing llc to re-order the passes (and be
> like opt) could be an easy fix.
> 
> But always remember: both opt and llc are *debug* tools. If you build
> a compiler with LLVM you should use the middle and back end classes
> inside your front-end driver.
> 
> Emitting IR and using opt/llc is only a way to bootstrap your
> front-end, and not meant to be embedded in a final product.
> 
> As an example, if we change llc to be like opt here, all the other
> tools that rely on llc's behaviour will change unexpectedly, and this
> may break or generate worse code for them. You don't want to be in
> that situation.
> 
> But it would be good if both opt and llc behave in similar ways, so
> that you can bootstrap products and run more reliable tests with them.
> 
> cheers,
> --renato
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev