Dumping out compiler intermediate structures

`-noC':

Don't bother generating C output or an interface file. Usually used in conjunction with one or more of the `-ddump-*' options; for example: `ghc -noC -ddump-simpl Foo.hs'

`-hi':

Do generate an interface file. This would normally be used in conjunction with `-noC', which turns off interface generation; thus: `-noC -hi'.

`-dshow-passes':

Prints a message to stderr as each pass starts. Gives a warm but undoubtedly misleading feeling that GHC is telling you what's happening.

`-ddump-<pass>':

Make a debugging dump after pass `<pass>' (may be common enough to need a short form...). Some of the most useful ones are:

`-ddump-rdr'         reader output (earliest stuff in the compiler)    
`-ddump-rn'          renamer output                                    
`-ddump-tc'          typechecker output                                
`-ddump-deriv'       derived instances                                 
`-ddump-ds'          desugarer output                                  
`-ddump-simpl'       simplifer output (Core-to-Core passes)            
`-ddump-stranal'     strictness analyser output                        
`-ddump-occur-anal'  `occurrence analysis' output                      
`-ddump-spec'        dump specialisation info                          
`-ddump-stg'         output of STG-to-STG passes                       
`-ddump-absC'        unflattened Abstract C                     
`-ddump-flatC'       flattened Abstract C                       
`-ddump-realC'       same as what goes to the C compiler               
`-ddump-asm'         assembly language from the native-code generator  

`-dverbose-simpl' and `-dverbose-stg':

Show the output of the intermediate Core-to-Core and STG-to-STG passes, respectively. (Lots of output!) So: when we're really desperate:

% ghc -noC -O -ddump-simpl -dverbose-simpl -dcore-lint Foo.hs

`-dppr-{user,debug,all}':

Debugging output is in one of several "styles." Take the printing of types, for example. In the "user" style, the compiler's internal ideas about types are presented in Haskell source-level syntax, insofar as possible. In the "debug" style (which is the default for debugging output), the types are printed in the most-often-desired form, with explicit foralls, etc. In the "show all" style, very verbose information about the types (e.g., the Uniques on the individual type variables) is displayed.

`-ddump-raw-asm':

Dump out the assembly-language stuff, before the "mangler" gets it.

`-ddump-rn-trace':

Make the renamer be *real* chatty about what it is upto.

`-dshow-rn-stats':

Print out summary of what kind of information the renamer had to bring in.

`-dshow-unused-imports':

Have the renamer report what imports does not contribute.