[LLVMdev] How to use LLVM optimizations with clang

Abdul Wahid Memon engrwahidmemon at gmail.com
Tue Jun 12 00:36:38 PDT 2012 

Hello

I need some help here please.

If we compile source files directly in to native code:
$ clang -O3 -lm *.c

then the runtime is like following

real	0m2.807s
user	0m2.784s
sys	0m0.012s

and If we emit LLVM bytcode and apply optimizations

$ clang -O3 -c -emit-llvm *.c
$ llvm-link *.o -o comb.ll
$ time lli ./comb.ll

then the runtime is

real	0m2.671s
user	0m2.640s
sys	0m0.020s

But, if I convert this same file comb,ll in to native binary

$ clang comb.ll

and execute it, then the runtime increases alot

$ time ./a.out

real	0m8.008s
user	0m7.964s

The binary generated directly by clang have runtime of around 2
seconds while generated after LLVM IR have around 8 secs but LLVM
bytecode having same optimizations when executed with lli have runtime
of around 2 secs.

What steps are exactly taken by clang to produce the binary in order
to achieve the runtime of around 2 secs. If it is a question of link
time optimizations then how can we achieve that?

Best Regards

Shahzad

On Fri, Jun 8, 2012 at 7:29 PM, Abdul Wahid Memon
<engrwahidmemon at gmail.com> wrote:
> Thanks Duncan
>
> It was really helpful.
>
> Regards
>
> Abdul
>
> On Fri, Jun 8, 2012 at 7:23 PM, Duncan Sands <baldrick at free.fr> wrote:
>> Hi,
>>
>>
>>> If I compile the program using the following command line i.e.
>>>
>>> $ clang -O3 -lm *.c
>>
>>
>> this may be doing link time optimization.
>>
>>
>>>
>>> then
>>>
>>> $ time ./a.out
>>>
>>> real    0m2.606s
>>> user    0m2.584s
>>> sys     0m0.012s
>>>
>>> BUT, if I use all the optimizations enabled with -O3 but specify them
>>> explicity i.e.
>>
>>
>> you can just use "opt -O3" here.
>>
>>
>>>
>>> for F in *.c ; do B=`basename $F .c` ; gcc
>>> -fplugin=/damm/compilers/dragonegg-3.1.src/dragonegg.so -S -o - $F
>>> -fplugin-arg-dragonegg-emit-ir | opt -targetlibinfo -no-aa -tbaa
>>> -basicaa -globalopt -ipsccp -deadargelim -instcombine -simplifycfg
>>> -basiccg -prune-eh -inline -functionattrs -argpromotion
>>> -scalarrepl-ssa -domtree -early-cse -simplify-libcalls
>>> -lazy-value-info -jump-threading -correlated-propagation -simplifycfg
>>> -instcombine -tailcallelim -simplifycfg -reassociate -domtree -loops
>>> -loop-simplify -lcssa -loop-rotate -licm -lcssa -loop-unswitch
>>> -instcombine -scalar-evolution -loop-simplify -lcssa -indvars
>>> -loop-idiom -loop-deletion -loop-unroll -memdep -gvn -memdep
>>> -memcpyopt -sccp -instcombine -lazy-value-info -jump-threading
>>> -correlated-propagation -domtree -memdep -dse -adce -simplifycfg
>>> -instcombine -strip-dead-prototypes -globaldce -constmerge -preverify
>>> -domtree -verify -o $B.ll ; done
>>>
>>> $ clang *.ll
>>
>>
>> Try clang -O3 *.ll
>>
>> If it makes a difference then that means that clang is linking all these
>> files
>> together to form one mega file which it is then optimizing.
>>
>> Ciao, Duncan.
>>
>>
>>>
>>> then
>>>
>>> time ./a.out
>>>
>>> real    0m7.791s
>>> user    0m7.760s
>>> sys     0m0.008s
>>>
>>> Am I missing something here?
>>>
>>> Though directly compiling files i.e.
>>>
>>> $ clang *.c
>>>
>>> results in
>>>
>>> time ./a.out
>>>
>>> real    0m10.167s
>>> user    0m10.121s
>>> sys     0m0.016s
>>>
>>> Regards
>>>
>>> Shahzad
>>>
>>> On Fri, Jun 8, 2012 at 7:00 PM, Duncan Sands<baldrick at free.fr>  wrote:
>>>>
>>>> Hi,
>>>>
>>>>
>>>>> I tried it with -o - but its producing an error
>>>>>
>>>>> gcc: fatal error: cannot specify -o with -c, -S or -E with multiple
>>>>> files
>>>>>
>>>>> What you suggest?
>>>>
>>>>
>>>>
>>>> what I wrote:
>>>>
>>>>>>  for F in *.c ; do B=`basename $F .c` ; gcc
>>>>>> -fplugin=/path/to/dragonegg.so
>>>>>> -S -o - $F -fplugin-arg-dragonegg-emit-ir | opt -adce -o $B.ll ; done
>>>>>>  clang *.ll
>>>>
>>>>
>>>>
>>>> Thanks to the for loop and passing $F to gcc, you are no longer using gcc
>>>> with
>>>> multiple files.  So if you are getting that message then you are don't
>>>> what
>>>> I
>>>> suggested.
>>>>
>>>> Ciao, Duncan.
>>>>
>>>>
>>>>>>
>>>>>> Ciao, Duncan.
>>>>>>
>>>>>>
>>>>>>>
>>>>>>> $ clang *.s
>>>>>>>
>>>>>>> Regards
>>>>>>>
>>>>>>> Shahzad
>>>>>>>
>>>>>>> On Fri, Jun 8, 2012 at 9:10 AM, Duncan Sands<baldrick at free.fr>
>>>>>>>  wrote:
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> Hi Shahzad,
>>>>>>>>
>>>>>>>>
>>>>>>>>> Is it possible that we can use LLVM optimization beside O1, O2, O3
>>>>>>>>> along with dragonegg plugin?
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>>
>>>>>>>> sure, try this:
>>>>>>>>
>>>>>>>>  gcc -fplugin=path/dragonegg.so ...other_options_here... -S -o -
>>>>>>>> -fplugin-arg-dragonegg-emit-ir
>>>>>>>> -fplugin-arg-dragonegg-llvm-ir-optimize=0
>>>>>>>> |
>>>>>>>> opt -pass1 -pass2 ...
>>>>>>>>
>>>>>>>> Here -fplugin-arg-dragonegg-emit-ir tells it to output LLVM IR rather
>>>>>>>> than
>>>>>>>> target assembler.  You can also use -flto here.
>>>>>>>>
>>>>>>>> -fplugin-arg-dragonegg-llvm-ir-optimize=0 disables the standard set
>>>>>>>> of
>>>>>>>> LLVM
>>>>>>>> optimizations.
>>>>>>>>
>>>>>>>> In general, if a front-end can produce LLVM IR then you can do this,
>>>>>>>> by
>>>>>>>> outputting the IR and passing it to "opt".
>>>>>>>>
>>>>>>>> Ciao, Duncan.
>>>>>>>>
>>>>>>>>
>>>>>>>>>
>>>>>>>>> Regards
>>>>>>>>>
>>>>>>>>> Shahzad
>>>>>>>>>
>>>>>>>>> On Thu, Jun 7, 2012 at 10:59 PM, Abdul Wahid Memon
>>>>>>>>> <engrwahidmemon at gmail.com>        wrote:
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Thanks alot Chad for these quick and fine responses.
>>>>>>>>>>
>>>>>>>>>> Regards
>>>>>>>>>>
>>>>>>>>>> Abdul
>>>>>>>>>>
>>>>>>>>>> On Thu, Jun 7, 2012 at 10:57 PM, Chad Rosier<mcrosier at apple.com>
>>>>>>>>>>  wrote:
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> On Jun 7, 2012, at 1:53 PM, Abdul Wahid Memon wrote:
>>>>>>>>>>>
>>>>>>>>>>>> Thanks again chad. One more question please.
>>>>>>>>>>>>
>>>>>>>>>>>> Is it possible that I can use these optimization using dragonegg
>>>>>>>>>>>> plugin
>>>>>>>>>>>> somehow?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> I haven't a clue.  Maybe Duncan can answer that?
>>>>>>>>>>>
>>>>>>>>>>>  Chad
>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Regards
>>>>>>>>>>>>
>>>>>>>>>>>> Shahzad
>>>>>>>>>>>>
>>>>>>>>>>>> On Thu, Jun 7, 2012 at 10:51 PM, Chad Rosier<mcrosier at apple.com>
>>>>>>>>>>>>  wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> On Jun 7, 2012, at 1:48 PM, Abdul Wahid Memon wrote:
>>>>>>>>>>>>>
>>>>>>>>>>>>>> On Thu, Jun 7, 2012 at 10:44 PM, Chad
>>>>>>>>>>>>>> Rosier<mcrosier at apple.com>
>>>>>>>>>>>>>>  wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> On Jun 7, 2012, at 1:39 PM, Abdul Wahid Memon wrote:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thanks alot Chad for quick response. Does this means that, we
>>>>>>>>>>>>>>>> can
>>>>>>>>>>>>>>>> not
>>>>>>>>>>>>>>>> use LLVM optimizations except O1, O2, O3, O4 and unroll-loops
>>>>>>>>>>>>>>>> with
>>>>>>>>>>>>>>>> clang?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Try using the -debug-pass=Arguments options to see what passes
>>>>>>>>>>>>>>> are
>>>>>>>>>>>>>>> being run at each optimization level.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes, I have seen those optimization but I want to disable all
>>>>>>>>>>>>>> the
>>>>>>>>>>>>>> default optimization (-O0) and specify them individually to
>>>>>>>>>>>>>> test
>>>>>>>>>>>>>> their
>>>>>>>>>>>>>> effect.
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> 1. Generate the bitcode/ir with -O0
>>>>>>>>>>>>> 2. Run opt with the optimization in question.  You should be
>>>>>>>>>>>>> able
>>>>>>>>>>>>> to
>>>>>>>>>>>>> specify most any pass with opt.
>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> E.g.,
>>>>>>>>>>>>>>> clang -O[0-3] -mllvm -debug-pass=Arguments foo.c.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> One more thing I would like to know that If I want to process
>>>>>>>>>>>>>>>> multiple
>>>>>>>>>>>>>>>> modules with opt at the same time like
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> opt -adce *.bc
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> I don't think this will work.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ok.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> then how is it possible with opt in one go, if I process all
>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>> bytecode files within Makefile.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> You should be able to define a rule in the Makefile to compile
>>>>>>>>>>>>>>> your
>>>>>>>>>>>>>>> bitcode/IR files.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> ok. I got the point.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Thanks alot
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Shahzad
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>  Chad
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Thanks.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Shahzad
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> On Thu, Jun 7, 2012 at 9:22 PM, Chad
>>>>>>>>>>>>>>>> Rosier<mcrosier at apple.com>
>>>>>>>>>>>>>>>>  wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> On Jun 7, 2012, at 10:59 AM, Abdul Wahid Memon wrote:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Hello everyone
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> I am trying to use some LLVM optimizations like -die or
>>>>>>>>>>>>>>>>>> -adce.
>>>>>>>>>>>>>>>>>> Is
>>>>>>>>>>>>>>>>>> it
>>>>>>>>>>>>>>>>>> possible to use them along clang?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Or is there a way where these optimization can be passed on
>>>>>>>>>>>>>>>>>> to
>>>>>>>>>>>>>>>>>> "opt"
>>>>>>>>>>>>>>>>>> tool through clang, if opt is being used by clang behind
>>>>>>>>>>>>>>>>>> the
>>>>>>>>>>>>>>>>>> scenes?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> No, opt only works on llvm IR/bitcode.  You can generate it
>>>>>>>>>>>>>>>>> like
>>>>>>>>>>>>>>>>> this:
>>>>>>>>>>>>>>>>> clang -c foo.c -emit-llvm -o foo.bc
>>>>>>>>>>>>>>>>> or
>>>>>>>>>>>>>>>>> clang -S foo.c -emit-llvm -o foo.ll
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then you can run the optimization(s):
>>>>>>>>>>>>>>>>> opt -adce foo.bc -o foo-adce.bc
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Then you can compile using clang
>>>>>>>>>>>>>>>>> clang -c foo-adce.bc -o foo-adce.o
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>  Chad
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Thanks alot
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Regards
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Shahzad
>>>>>>>>>>>>>>>>>> _______________________________________________
>>>>>>>>>>>>>>>>>> LLVM Developers mailing list
>>>>>>>>>>>>>>>>>> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
>>>>>>>>>>>>>>>>>> http://lists.cs.uiuc.edu/mailman/listinfo/llvmdev
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>
>>>>>>
>>>>
>>

More information about the llvm-dev mailing list