IL optimization for JIT compilers

Question

I am developing a compiler that emits IL code. It is important that the resulting IL is JIT'ted to the fastest possible machine codes by Mono and Microsoft .NET JIT compilers.

My questions are:

1. Does it make sense to optimize patterns like:

   'stloc.0; ldloc.0; ret' => 'ret' 
   'ldc.i4.0; conv.r8' => 'ldc.r8.0'
   

   and such, or are the JIT's smart enough to take care of these?

2. Is there a specification with the list of optimizations performed by Microsoft/Mono JIT compilers?

3. Is there any good read with practical recommendations / best practices to optimize IL so that JIT compilers can in turn generate the most optimal machine code (performance-wise)?

Answer 1

1. The two patterns yo described are the easy stuff that the JIT actually gets right (except for non-primitive structs). In SSA form constant propagation and elimination of dead values is very easy.
2. No, you have to test what the JIT can do. Look into compiler literature to see what standard optimizations to expect. Then, test for them. The two JITs that we have right now optimize very little and sometimes do not get the most basic stuff right. For example, MyStruct s; s.x = 1; s.x = 1; is not optimized by RyuJIT. s = s; isn't either. s.x + s.x loads x twice from memory. Expect little.
3. You need to understand what machine code basic operations map to. This is not too complicated. Try a few things and look at the disassembly listing. You'll quickly get a feel for what the output is going to look like.