Hey everyone,
I'm running stock LLVM 3.1 release. Both llc and opt programs have the
-O# arguments, however it looks like the results are somewhat
different. Here's a silly unoptimized bit of code which I'm generating
from my LLVM-backed program
; ModuleID = 'foo'
%Coord = type { double, double, double }
define double @foo(%Coord*, %Coord*) nounwind uwtable ssp {
entry:
%dx_ptr = alloca double
%b_ptr = alloca %Coord*
%a_ptr = alloca %Coord*
store %Coord* %0, %Coord** %a_ptr
store %Coord* %1, %Coord** %b_ptr
%a = load %Coord** %a_ptr
%addr = getelementptr %Coord* %a, i64 0
%2 = getelementptr inbounds %Coord* %addr, i32 0, i32 0
%3 = load double* %2
%b = load %Coord** %b_ptr
%addr1 = getelementptr %Coord* %b, i64 0
%4 = getelementptr inbounds %Coord* %addr1, i32 0, i32 0
%5 = load double* %4
%sub = fsub double %3, %5
store double %sub, double* %dx_ptr
%dx = load double* %dx_ptr
%dx2 = load double* %dx_ptr
%mult = fmul double %dx, %dx2
ret double %mult
}
This roughly matches the following C code
struct Coord { double x; double y; double z; };
double foo(struct Coord * a, struct Coord * b) {
dx = a[0].x - a[0].y;
return dx * dx;
}
Running through opt
$ llvm-as < x.ll | opt -O3 | llc > y.s
Produces the following:
_foo: ## @foo
.cfi_startproc
## BB#0: ## %entry
movsd (%rdi), %xmm0
subsd (%rsi), %xmm0
mulsd %xmm0, %xmm0
ret
.cfi_endproc
This also matches what clang compiles from the C function. However,
running through llc with the same optimization flag
$ llc -O3 x.ll -o z.s
_foo: ## @foo
.cfi_startproc
## BB#0: ## %entry
movq %rdi, -24(%rsp)
movq %rsi, -16(%rsp)
movq -24(%rsp), %rax
movsd (%rax), %xmm0
subsd (%rsi), %xmm0
movsd %xmm0, -8(%rsp)
mulsd %xmm0, %xmm0
ret
.cfi_endproc
This matches the results of LLVMCreateTargetMachine with
CodeGenLevelAggressive followed by LLVMTargetMachineEmitToFile which
I'm using.
.
Is the llc/opt difference expected? I'm a bit confused since I'd
expect same -O level running the same optimization passes. I have to
admit I'm not well versed in assembly but to me it looks like opt
produces something that eliminates a bunch of stack loading ops. I'd
appreciate any insight into this.
Thanks,
Dimitri
Dimitri Tcaciuc wrote:> Is the llc/opt difference expected?Yes. "opt" runs the optimizers, which take LLVM IR as input and produce LLVM IR as output. "opt -O2 -debug-pass=Arguments" will show you a list of the individual optimizations (and analyses) that opt -O2 performs. It's possible to run them individually (opt -scalarrepl -instcombine) to create a list that's better for your own compiler, but -O2 has the ones we think are good for a C/C++ compiler. "llc" is the code generator, which takes LLVM IR in and produces machine code. There are some places in the code generator where it has the choice between spending compile time to produce good code, or getting the code out quickly, and the -O flag to llc specifies that choice. For example, you can do register allocation by trying to figure out the most efficient registers that minimize the number of spills, or you can just pick the registers starting from one, and spill it if it's already used. Any optimizations llc does are things that can't possibly happen in an IR-to-IR pass (since the IR is SSA form, we can't do register allocation there). If you want optimized code, you'd run the IR optimizers and ask the code generator to spend time producing good code. Or if you want unoptimized code, don't run any IR optimizers and ask the code generator to produce code as quickly as it can. You can of course choose some other combination by running opt and llc yourself, as you noticed. Nick
Great, thanks for the info! So to extrapolate, (referring to LLVM C bindings) running PassManager + populating PassManagerBuilder at it's own OptLevel actually takes care of different category of optimizations and will not step on what Target machine CodeGenLevel argument + TargetMachineEmitToFile are working on? Dimitri. On Sat, Jun 30, 2012 at 1:28 PM, Nick Lewycky <nicholas at mxc.ca> wrote:> Dimitri Tcaciuc wrote: >> >> Is the llc/opt difference expected? > > > Yes. "opt" runs the optimizers, which take LLVM IR as input and produce LLVM > IR as output. "opt -O2 -debug-pass=Arguments" will show you a list of the > individual optimizations (and analyses) that opt -O2 performs. It's possible > to run them individually (opt -scalarrepl -instcombine) to create a list > that's better for your own compiler, but -O2 has the ones we think are good > for a C/C++ compiler. > > "llc" is the code generator, which takes LLVM IR in and produces machine > code. There are some places in the code generator where it has the choice > between spending compile time to produce good code, or getting the code out > quickly, and the -O flag to llc specifies that choice. For example, you can > do register allocation by trying to figure out the most efficient registers > that minimize the number of spills, or you can just pick the registers > starting from one, and spill it if it's already used. Any optimizations llc > does are things that can't possibly happen in an IR-to-IR pass (since the IR > is SSA form, we can't do register allocation there). > > If you want optimized code, you'd run the IR optimizers and ask the code > generator to spend time producing good code. Or if you want unoptimized > code, don't run any IR optimizers and ask the code generator to produce code > as quickly as it can. You can of course choose some other combination by > running opt and llc yourself, as you noticed. > > Nick