GHC supports multiple backend code generators. This is the part of the compiler responsible for taking the last intermediate representation that GHC uses (a form called Cmm that is a simple, C like language) and compiling it to executable code. The backends that GHC support are described below.
-fasm flag.
  This is an alternative backend that uses the
      LLVM compiler to produce
      executable code. It generally produces code as with performance as
      good as the native code generator but for some cases can produce
      much faster code. This is especially true for numeric, array heavy
      code using packages like vector. The penalty is a significant increase in
      compilation times. Select the LLVM backend with the
      -fllvm flag. Currently LLVM 2.8 and
      later are supported.
    
You must install and have LLVM available on your PATH for the LLVM code generator to work. Specifically GHC needs to be able to call the optand llc tools. Secondly, if you are running Mac OS X with LLVM 3.0 or greater then you also need the Clang c compiler compiler available on your PATH. Clang and LLVM are both included with OS X by default from 10.6 onwards.
To install LLVM and Clang:
10.6 and later. For
          10.5 you should install the
          Homebrew package
          manager for OS X. Alternatively you can download binaries for LLVM
          and Clang from
          here.
        
This is the oldest code generator in GHC and is generally not included
      any more having been deprecated around GHC 7.0. Select it with the
      -fvia-C flag.
    
The C code generator is only supported when GHC is built in
      unregisterised mode, a mode where GHC produces 'portable' C code as
      output to facilitate porting GHC itself to a new platform. This mode
      produces much slower code though so it's unlikely your version of
      GHC was built this way. If it has then the native code generator
      probably won't be available. You can check this information by calling
      ghc --info.
    
The term "unregisterised" really means "compile via vanilla C", disabling some of the platform-specific tricks that GHC normally uses to make programs go faster. When compiling unregisterised, GHC simply generates a C file which is compiled via gcc.
When GHC is build in unregisterised mode only the LLVM and C code generators will be available. The native code generator won't be. LLVM usually offers a substantial performance benefit over the C backend in unregisterised mode.
Unregisterised compilation can be useful when porting GHC to a new machine, since it reduces the prerequisite tools to gcc, as, and ld and nothing more, and furthermore the amount of platform-specific code that needs to be written in order to get unregisterised compilation going is usually fairly small.
Unregisterised compilation cannot be selected at compile-time; you have to build GHC with the appropriate options set. Consult the GHC Building Guide for details.
You can check if your GHC is unregisterised by calling
      ghc --info.