8. Using GHC

• 8.1. Using GHC
  • 8.1.1. Getting started: compiling programs
  • 8.1.2. Options overview
    • 8.1.2.1. Command-line arguments
    • 8.1.2.2. Command line options in source files
    • 8.1.2.3. Setting options in GHCi
  • 8.1.3. Static, Dynamic, and Mode options
  • 8.1.4. Meaningful file suffixes
  • 8.1.5. Modes of operation
    • 8.1.5.1. Using ghc --make
    • 8.1.5.2. Expression evaluation mode
    • 8.1.5.3. Batch compiler mode
      • 8.1.5.3.1. Overriding the default behaviour for a file
  • 8.1.6. Verbosity options
  • 8.1.7. Platform-specific Flags
  • 8.1.8. Miscellaneous flags
• 8.2. Warnings and sanity-checking
• 8.3. Optimisation (code improvement)
  • 8.3.1. -O*: convenient “packages” of optimisation flags.
  • 8.3.2. -f*: platform-independent flags
• 8.4. Using Concurrent Haskell
• 8.5. Using SMP parallelism
  • 8.5.1. Compile-time options for SMP parallelism
  • 8.5.2. RTS options for SMP parallelism
  • 8.5.3. Hints for using SMP parallelism
• 8.6. Flag reference
  • 8.6.1. Verbosity options
  • 8.6.2. Alternative modes of operation
  • 8.6.3. Which phases to run
  • 8.6.4. Redirecting output
  • 8.6.5. Keeping intermediate files
  • 8.6.6. Temporary files
  • 8.6.7. Finding imports
  • 8.6.8. Interface file options
  • 8.6.9. Recompilation checking
  • 8.6.10. Interactive-mode options
  • 8.6.11. Packages
  • 8.6.12. Language options
  • 8.6.13. Warnings
  • 8.6.14. Optimisation levels
  • 8.6.15. Individual optimisations
  • 8.6.16. Profiling options
  • 8.6.17. Program coverage options
  • 8.6.18. C pre-processor options
  • 8.6.19. Code generation options
  • 8.6.20. Linking options
  • 8.6.21. Plugin options
  • 8.6.22. Replacing phases
  • 8.6.23. Forcing options to particular phases
  • 8.6.24. Platform-specific options
  • 8.6.25. Compiler debugging options
  • 8.6.26. Miscellaneous compiler options
• 8.7. Running a compiled program
  • 8.7.1. Setting RTS options
    • 8.7.1.1. Setting RTS options on the command line
    • 8.7.1.2. Setting RTS options at compile time
    • 8.7.1.3. Setting RTS options with the GHCRTS environment variable
    • 8.7.1.4. “Hooks” to change RTS behaviour
      • 8.7.1.4.1. Runtime events
      • 8.7.1.4.2. Event log output
  • 8.7.2. Miscellaneous RTS options
  • 8.7.3. RTS options to control the garbage collector
  • 8.7.4. RTS options to produce runtime statistics
  • 8.7.5. RTS options for concurrency and parallelism
  • 8.7.6. RTS options for profiling
  • 8.7.7. Tracing
  • 8.7.8. RTS options for hackers, debuggers, and over-interested souls
  • 8.7.9. Getting information about the RTS
• 8.8. Filenames and separate compilation
  • 8.8.1. Haskell source files
  • 8.8.2. Output files
  • 8.8.3. The search path
  • 8.8.4. Redirecting the compilation output(s)
  • 8.8.5. Keeping Intermediate Files
  • 8.8.6. Redirecting temporary files
  • 8.8.7. Other options related to interface files
  • 8.8.8. The recompilation checker
  • 8.8.9. How to compile mutually recursive modules
  • 8.8.10. Module signatures
  • 8.8.11. Using make
  • 8.8.12. Dependency generation
  • 8.8.13. Orphan modules and instance declarations
• 8.9. Packages
  • 8.9.1. Using Packages
  • 8.9.2. The main package
  • 8.9.3. Consequences of packages for the Haskell language
  • 8.9.4. Thinning and renaming modules
  • 8.9.5. Package Databases
    • 8.9.5.1. The GHC_PACKAGE_PATH environment variable
    • 8.9.5.2. Package environments
  • 8.9.6. Installed package IDs, dependencies, and broken packages
  • 8.9.7. Package management (the ghc-pkg command)
  • 8.9.8. Building a package from Haskell source
  • 8.9.9. InstalledPackageInfo: a package specification
• 8.10. GHC Backends
  • 8.10.1. Native Code Generator (-fasm)
  • 8.10.2. LLVM Code Generator (-fllvm)
  • 8.10.3. C Code Generator (-fvia-C)
  • 8.10.4. Unregisterised compilation
• 8.11. Options related to a particular phase
  • 8.11.1. Replacing the program for one or more phases
  • 8.11.2. Forcing options to a particular phase
  • 8.11.3. Options affecting the C pre-processor
    • 8.11.3.1. Standard CPP macros
    • 8.11.3.2. CPP and string gaps
  • 8.11.4. Options affecting a Haskell pre-processor
  • 8.11.5. Options affecting code generation
  • 8.11.6. Options affecting linking
• 8.12. Using shared libraries
  • 8.12.1. Building programs that use shared libraries
  • 8.12.2. Shared libraries for Haskell packages
  • 8.12.3. Shared libraries that export a C API
  • 8.12.4. Finding shared libraries at runtime
    • 8.12.4.1. Unix
    • 8.12.4.2. Mac OS X
• 8.13. Debugging the compiler
  • 8.13.1. Dumping out compiler intermediate structures
    • 8.13.1.1. Front-end
    • 8.13.1.2. Type-checking and renaming
    • 8.13.1.3. Core representation and simplification
    • 8.13.1.4. STG representation
    • 8.13.1.5. C-\- representation
    • 8.13.1.6. LLVM code generator
    • 8.13.1.7. Native code generator
    • 8.13.1.8. Miscellaneous backend dumps
  • 8.13.2. Formatting dumps
  • 8.13.3. Suppressing unwanted information
  • 8.13.4. Checking for consistency
  • 8.13.5. Checking for determinism