GHC

NAME

SYNOPSIS

DESCRIPTION

Each of GHC's command line options is classified as either static or dynamic. A static flag may only be specified on the command line, whereas a dynamic flag may also be given in an OPTIONS pragma in a source file or set from the GHCi command-line with :set.

As a rule of thumb, all the language options are dynamic, as are the warning options and the debugging options.

The rest are static, with the notable exceptions of -v, -cpp, -fasm, -fvia-C, and -#include. The OPTIONS sections lists the status of each flag.

Common suffixes of file names for Haskell are:

.hs

Haskell source code; preprocess, compile

.lhs

literate Haskell source; unlit, preprocess, compile

.hi

Interface file; contains information about exported symbols

.hc

intermediate C files

.x_o

way x object files; common ways are: p, u, s

.x_hi

way x interface files

OPTIONS

Help and verbosity options

Which phases to run

Alternative modes of operation

Redirecting output

Keeping intermediate files

Temporary files

Finding imports

Interface file options

Recompilation checking

Interactive-mode options

Packages

Language options

Warnings

Optimisation levels

Individual optimisations

Profiling options

Program coverage options

Haskell pre-processor options

C pre-processor options

C compiler options

Code generation options

Linking options

Replacing phases

Forcing options to particular phases

Platform-specific options

External core file options

Compiler debugging options

Misc compiler options

HELP AND VERBOSITY OPTIONS

-?

help [mode]

-help

help [mode]

-n

do a dry run [dynamic]

-v

verbose mode (equivalent to -v3) [dynamic]

-vn

set verbosity level [dynamic]

-V

display GHC version [mode]

--supported-languages

display the supported language extensions [mode]

--info

display information about the compiler [mode]

--version

display GHC version [mode]

--numeric-version

display GHC version (numeric only) [mode]

--print-libdir

display GHC library directory [mode]

-ferror-spans

output full span in error messages [static]

-Hsize

Set the minimum heap size to size [static]

-Rghc-timing

Summarise timing stats for GHC (same as +RTS -tstderr) [static]

WHICH PHASES TO RUN

-E

Stop after preprocessing (.hspp file) [mode]

-C

Stop after generating C (.hc file) [mode]

-S

Stop after generating assembly (.s file) [mode]

-c

Do not link [dynamic]

-x suffix

Override default behaviour for source files [static]

ALTERNATIVE MODES OF OPERATION

--interactive

Interactive mode - normally used by just running ghci; see for details. [mode]

--make

Build a multi-module Haskell program, automatically figuring out dependencies. Likely to be much easier, and faster, than using make; see for details.. [mode]

-e expr

Evaluate expr; see for details. [mode]

-M

Generate dependency information suitable for use in a Makefile; see for details. [mode]

REDIRECTING OUTPUT

-hcsuf suffix

set the suffix to use for intermediate C files [dynamic]

-hidir dir

set directory for interface files [dynamic]

-hisuf suffix

set the suffix to use for interface files [dynamic]

-o filename

set output filename [dynamic]

-odir dir

set directory for object files [dynamic]

-ohi filename

set the filename in which to put the interface [dynamic]

-osuf suffix

set the output file suffix [dynamic]

-stubdir dir

redirect FFi stub files [dynamic]

-outputdir dir

set output directory [dynamic]

KEEPING INTERMEDIATE FILES

-keep-hc-file or

                 -keep-hc-files  retain intermediate .hc files [dynamic]

-keep-s-file or

                 -keep-s-files  retain intermediate .s files [dynamic]

-keep-raw-s-file or

                 -keep-raw-s-files  retain intermediate .raw_s files [dynamic]

-keep-tmp-files

retain all intermediate temporary files [dynamic]

TEMPORARY FILES

-tmpdir

set the directory for temporary files [dynamic]

FINDING IMPORTS

-idir1:dir2:...

add dir, dir2, etc. to import path [static/:set]

-i

Empty the import directory list [static/:set]

INTERFACE FILE OPTIONS

-ddump-hi

Dump the new interface to stdout [dynamic]

-ddump-hi-diffs

Show the differences vs. the old interface [dynamic]

-ddump-minimal-imports

Dump a minimal set of imports [dynamic]

--show-iface file

See . []

RECOMPILATION CHECKING

-fforce-recomp

Turn off recompilation checking; implied by any -ddump-X option [dynamic]

INTERACTIVE-MODE OPTIONS

-ignore-dot-ghci

Disable reading of .ghci files [static]

-read-dot-ghci

Enable reading of .ghci files [static]

-fbreak-on-exception

Break on any exception thrown [dynamic]

-fbreak-on-error

Break on uncaught exceptions and errors [dynamic]

-fprint-evld-with-show

Enable usage of Show instances in :print [dynamic]

-fprint-bind-result

Turn on printing of binding results in GHCi [dynamic]

-fno-print-bind-contents

Turn off printing of binding contents in GHCi [dynamic]

-fno-implicit-import-qualified

Turn off implicit qualified import of everything in GHCi [dynamic]

PACKAGES

-package-name P

Compile to be part of package P [dynamic]

-package P

Expose package P [static/:set]

-hide-all-packages

Hide all packages by default [static]

-hide-package name

Hide package P [static/:set]

-ignore-package name

Ignore package P [static/:set]

-package-conf file

Load more packages from file [static]

-no-user-package-conf

Don't load the user's package config file. [static]

LANGUAGE OPTIONS

-fglasgow-exts

Enable most language extensions [dynamic]

-XOverlappingInstances

Enable overlapping instances [dynamic]

-XIncoherentInstances

Enable incoherent instances. Implies -XOverlappingInstances [dynamic]

-XUndecidableInstances

Enable undecidable instances [dynamic]

-fcontext-stack=Nn

set the limit for context reduction. Default is 20. [dynamic]

-XArrows

Enable arrow notation extension [dynamic]

-XDisambiguateRecordFields

Enable record field disambiguation [dynamic]

-XForeignFunctionInterface

Enable foreign function interface (implied by -fglasgow-exts) [dynamic]

-XGenerics

Enable generic classes [dynamic]

-XImplicitParams

Enable Implicit Parameters. Implied by -fglasgow-exts. [dynamic]

-firrefutable-tuples

Make tuple pattern matching irrefutable [dynamic]

-XNoImplicitPrelude

Don't implicitly import Prelude [dynamic]

-XNoMonomorphismRestriction

Disable the monomorphism restriction [dynamic]

-XNoMonoPatBinds

Make pattern bindings polymorphic [dynamic]

-XRelaxedPolyRec

Relaxed checking for mutually-recursive polymorphic functions [dynamic]

-XExtendedDefaultRules

Use GHCi's extended default rules in a normal module [dynamic]

-XOverloadedStrings

Enable overloaded string literals. [dynamic]

-XGADTs

Enable generalised algebraic data types. [dynamic]

-XTypeFamilies

Enable type families. [dynamic]

-XScopedTypeVariables

Enable lexically-scoped type variables. Implied by -fglasgow-exts. [dynamic]

-XTemplateHaskell

Enable Template Haskell. No longer implied by -fglasgow-exts. [dynamic]

-XQuasiQuotes

Enable quasiquotation. [dynamic]

-XBangPatterns

Enable bang patterns. [dynamic]

-XCPP

Enable the C preprocessor. [dynamic]

-XPatternGuards

Enable pattern guards. [dynamic]

-XViewPatterns

Enable view patterns. [dynamic]

-XUnicodeSyntax

Enable unicode syntax. [dynamic]

-XMagicHash

Allow "#" as a postfix modifier on identifiers. [dynamic]

-XNewQualifiedOperators

Enable new qualified operator syntax [dynamic]

-XPolymorphicComponents

Enable polymorphic components for data constructors. [dynamic]

-XRank2Types

Enable rank-2 types. [dynamic]

-XRankNTypes

Enable rank-N types. [dynamic]

-XImpredicativeTypes

Enable impredicative types. [dynamic]

-XExistentialQuantification

Enable existential quantification. [dynamic]

-XKindSignatures

Enable kind signatures. [dynamic]

-XEmptyDataDecls

Enable empty data declarations. [dynamic]

-XParallelListComp

Enable parallel list comprehensions. [dynamic]

-XTransformListComp

Enable transform list comprehensions. [dynamic]

-XUnliftedFFITypes

Enable unlifted FFI types. [dynamic]

-XLiberalTypeSynonyms

Enable liberalised type synonyms. [dynamic]

-XTypeOperators

Enable type operators. [dynamic]

-XRecursiveDo

Enable recursive do (mdo) notation. [dynamic]

-XPArr

Enable parallel arrays. [dynamic]

-XRecordWildCards

Enable record wildcards. [dynamic]

-XNamedFieldPuns

Enable record puns. [dynamic]

-XDisambiguateRecordFields

Enable record field disambiguation. [dynamic]

-XUnboxedTuples

Enable unboxed tuples. [dynamic]

-XStandaloneDeriving

Enable standalone deriving. [dynamic]

-XDeriveDataTypeable

Enable deriving for the Data and Typeable classes. [dynamic]

-XGeneralizedNewtypeDeriving

Enable newtype deriving. [dynamic]

-XTypeSynonymInstances

Enable type synonyms. [dynamic]

-XFlexibleContexts

Enable flexible contexts. [dynamic]

-XFlexibleInstances

Enable flexible instances. [dynamic]

-XConstrainedClassMethods

Enable constrained class methods. [dynamic]

-XMultiParamTypeClasses

Enable multi parameter type classes. [dynamic]

-XFunctionalDependencies

Enable functional dependencies. [dynamic]

-XPackageImports

Enable package-qualified imports. [dynamic]

WARNINGS

-W

enable normal warnings [dynamic]

-w

disable all warnings [dynamic]

-Wall

enable almost all warnings (details in ) [dynamic]

-Werror

make warnings fatal [dynamic]

-Wwarn

make warnings non-fatal [dynamic]

-fwarn-unrecognised-pragmas

warn about uses of pragmas that GHC doesn't recognise [dynamic]

-fwarn-warnings-deprecations

warn about uses of functions & types that have warnings or deprecated pragmas [dynamic]

-fwarn-deprecated-flags

warn about uses of commandline flags that are deprecated [dynamic]

-fwarn-duplicate-exports

warn when an entity is exported multiple times [dynamic]

-fwarn-hi-shadowing

warn when a .hi file in the current directory shadows a library [dynamic]

-fwarn-implicit-prelude

warn when the Prelude is implicitly imported [dynamic]

-fwarn-incomplete-patterns

warn when a pattern match could fail [dynamic]

-fwarn-incomplete-record-updates

warn when a record update could fail [dynamic]

-fwarn-missing-fields

warn when fields of a record are uninitialised [dynamic]

-fwarn-missing-methods

warn when class methods are undefined [dynamic]

-fwarn-missing-signatures

warn about top-level functions without signatures [dynamic]

-fwarn-name-shadowing

warn when names are shadowed [dynamic]

-fwarn-orphans

warn when the module contains orphan instance declarations or rewrite rules [dynamic]

-fwarn-overlapping-patterns

warn about overlapping patterns [dynamic]

-fwarn-simple-patterns

warn about lambda-patterns that can fail [dynamic]

-fwarn-tabs

warn if there are tabs in the source file [dynamic]

-fwarn-type-defaults

warn when defaulting happens [dynamic]

-fwarn-monomorphism-restriction

warn when the Monomorphism Restriction is applied [dynamic]

-fwarn-unused-binds

warn about bindings that are unused [dynamic]

-fwarn-unused-imports

warn about unnecessary imports [dynamic]

-fwarn-unused-matches

warn about variables in patterns that aren't used [dynamic]

OPTIMISATION LEVELS

-O

Enable default optimisation (level 1) [dynamic]

-On

Set optimisation level n [dynamic]

INDIVIDUAL OPTIMISATIONS

-fcase-merge

Enable case-merging. Implied by -O. [dynamic]

-fdicts-strict

Make dictionaries strict [static]

-fmethod-sharing

Share specialisations of overloaded functions (default) [dynamic]

-fdo-eta-reduction

Enable eta-reduction. Implied by -O. [dynamic]

-fdo-lambda-eta-expansion

Enable lambda eta-reduction [dynamic]

-fexcess-precision

Enable excess intermediate precision [dynamic]

-fignore-asserts

Ignore assertions in the source [dynamic]

-fignore-interface-pragmas

Ignore pragmas in interface files [dynamic]

-fomit-interface-pragmas

Don't generate interface pragmas [dynamic]

-fmax-worker-args

If a worker has that many arguments, none will be unpacked anymore (default: 10) [static]

-fsimplifier-phases

Set the number of phases for the simplifier (default 2). Ignored with -O0. [dynamic]

-fmax-simplifier-iterations

Set the max iterations for the simplifier [dynamic]

-fno-state-hack

Turn off the "state hack" whereby any lambda with a real-world state token as argument is considered to be single-entry. Hence OK to inline things inside it. [static]

-fcse

Turn on common sub-expression elimination. Implied by -O. [dynamic]

-ffull-laziness

Turn on full laziness (floating bindings outwards). Implied by -O. [dynamic]

-frewrite-rules

Switch on all rewrite rules (including rules generated by automatic specialisation of overloaded functions). Implied by -O. [dynamic]

-fstrictness

Turn on strictness analysis. Implied by -O. [dynamic]

-fspec-constr

Turn on the SpecConstr transformation. Implied by -O2. [dynamic]

-fspec-constr-threshold=n

Set the size threshold for the SpecConstr transformation to n (default: 200) [static]

-fspec-constr-count=n

Set to n (default: 3) the maximum number of specialisations that will be created for any one function by the SpecConstr transformation [static]

-fliberate-case

Turn on the liberate-case transformation. Implied by -O2. [dynamic]

-fstatic-argument-transformation

Turn on the static argument transformation. Implied by -O2. [dynamic]

-fliberate-case-threshold=n

Set the size threshold for the liberate-case transformation to n (default: 200) [static]

-funbox-strict-fields

Flatten strict constructor fields [dynamic]

-funfolding-creation-threshold

Tweak unfolding settings [static]

-funfolding-fun-discount

Tweak unfolding settings [static]

-funfolding-keeness-factor

Tweak unfolding settings [static]

-funfolding-use-threshold

Tweak unfolding settings [static]

-fno-pre-inlining

Turn off pre-inlining [static]

PROFILING OPTIONS

-auto

Auto-add _scc_s to all exported functions [static]

-auto-all

Auto-add _scc_s to all top-level functions [static]

-caf-all

Auto-add _scc_s to all CAFs [static]

-prof

Turn on profiling [static]

-ticky

Turn on ticky-ticky profiling [static]

PROGRAM COVERAGE OPTIONS

-fhpc

Turn on Haskell program coverage instrumentation [static]

-hpcdir dir

Directory to deposit .mix files during compilation (default is .hpc) [dynamic]

HASKELL PRE-PROCESSOR OPTIONS

-F

Enable the use of a pre-processor (set with -pgmF) [dynamic]

C PRE-PROCESSOR OPTIONS

-cpp

Run the C pre-processor on Haskell source files [dynamic]

-Dsymbol=value

Define a symbol in the C pre-processor [dynamic]

-Usymbol

Undefine a symbol in the C pre-processor [dynamic]

-Idir

Add dir to the directory search list for #include files [dynamic]

C COMPILER OPTIONS

-#include file

Include file when compiling the .hc file [dynamic]

CODE GENERATION OPTIONS

-fasm

Use the native code generator [dynamic]

-fvia-C

Compile via C [dynamic]

-fno-code

Omit code generation [dynamic]

-fbyte-code

Generate byte-code [dynamic]

-fobject-code

Generate object code [dynamic]

LINKING OPTIONS

-fPIC

Generate position-independent code (where available) [static]

-dynamic

Use dynamic Haskell libraries (if available) [static]

-framework name

On Darwin/MacOS X only, link in the framework name. This option corresponds to the -framework option for Apple's Linker. [dynamic]

-framework-path name

On Darwin/MacOS X only, add dir to the list of directories searched for frameworks. This option corresponds to the -F option for Apple's Linker. [dynamic]

-llib

Link in library lib [dynamic]

-Ldir

Add dir to the list of directories searched for libraries [dynamic]

-main-is

Set main module and function [dynamic]

--mk-dll

DLL-creation mode (Windows only) [dynamic]

-no-hs-main

Don't assume this program contains main [dynamic]

-no-link

Omit linking [dynamic]

-split-objs

Split objects (for libraries) [dynamic]

-static

Use static Haskell libraries [static]

-threaded

Use the threaded runtime [static]

-debug

Use the debugging runtime [static]

-fno-gen-manifest

Do not generate a manifest file (Windows only) [dynamic]

-fno-embed-manifest

Do not embed the manifest in the executable (Windows only) [dynamic]

REPLACING PHASES

-pgmL cmd

Use cmd as the literate pre-processor [dynamic]

-pgmP cmd

Use cmd as the C pre-processor (with -cpp only) [dynamic]

-pgmc cmd

Use cmd as the C compiler [dynamic]

-pgmm cmd

Use cmd as the mangler [dynamic]

-pgms cmd

Use cmd as the splitter [dynamic]

-pgma cmd

Use cmd as the assembler [dynamic]

-pgml cmd

Use cmd as the linker [dynamic]

-pgmdll cmd

Use cmd as the DLL generator [dynamic]

-pgmF cmd

Use cmd as the pre-processor (with -F only) [dynamic]

-pgmwindres cmd

Use cmd as the program for embedding manifests on Windows. [dynamic]

FORCING OPTIONS TO PARTICULAR PHASES

-optL option

pass option to the literate pre-processor [dynamic]

-optP option

pass option to cpp (with -cpp only) [dynamic]

-optF option

pass option to the custom pre-processor [dynamic]

-optc option

pass option to the C compiler [dynamic]

-optm option

pass option to the mangler [dynamic]

-opta option

pass option to the assembler [dynamic]

-optl option

pass option to the linker [dynamic]

-optdll option

pass option to the DLL generator [dynamic]

-optwindres option

pass option to windres. [dynamic]

PLATFORM-SPECIFIC OPTIONS

-monly-[432]-regs

(x86 only) give some registers back to the C compiler [dynamic]

EXTERNAL CORE FILE OPTIONS

-fext-core

Generate .hcr external Core files [static]

COMPILER DEBUGGING OPTIONS

-dcore-lint

Turn on internal sanity checking [dynamic]

-ddump-asm

Dump assembly [dynamic]

-ddump-bcos

Dump interpreter byte code [dynamic]

-ddump-cmm

Dump C-- output [dynamic]

-ddump-cpranal

Dump output from CPR analysis [dynamic]

-ddump-cse

Dump CSE output [dynamic]

-ddump-deriv

Dump deriving output [dynamic]

-ddump-ds

Dump desugarer output [dynamic]

-ddump-flatC

Dump `flat' C [dynamic]

-ddump-foreign

Dump foreign export stubs [dynamic]

-ddump-hpc

Dump after instrumentation for program coverage [dynamic]

-ddump-inlinings

Dump inlining info [dynamic]

-ddump-occur-anal

Dump occurrence analysis output [dynamic]

-ddump-opt-cmm

Dump the results of C-- to C-- optimising passes [dynamic]

-ddump-parsed

Dump parse tree [dynamic]

-ddump-prep

Dump prepared core [dynamic]

-ddump-rn

Dump renamer output [dynamic]

-ddump-rules

Dump rules [dynamic]

-ddump-simpl

Dump final simplifier output [dynamic]

-ddump-simpl-phases

Dump output from each simplifier phase [dynamic]

-ddump-simpl-iterations

Dump output from each simplifier iteration [dynamic]

-ddump-spec

Dump specialiser output [dynamic]

-ddump-splices

Dump TH spliced expressions, and what they evaluate to [dynamic]

-ddump-stg

Dump final STG [dynamic]

-ddump-stranal

Dump strictness analyser output [dynamic]

-ddump-tc

Dump typechecker output [dynamic]

-ddump-types

Dump type signatures [dynamic]

-ddump-worker-wrapper

Dump worker-wrapper output [dynamic]

-ddump-if-trace

Trace interface files [dynamic]

-ddump-tc-trace

Trace typechecker [dynamic]

-ddump-rn-trace

Trace renamer [dynamic]

-ddump-rn-stats

Renamer stats [dynamic]

-ddump-simpl-stats

Dump simplifier stats [dynamic]

-dno-debug-output

Suppress unsolicited debugging output [static]

-dppr-debug

Turn on debug printing (more verbose) [static]

-dsuppress-uniques

Suppress the printing of uniques in debug output (easier to use diff. [static]

-dppr-noprags

Don't output pragma info in dumps [static]

-dppr-user-length

Set the depth for printing expressions in error msgs [static]

-dsource-stats

Dump haskell source stats [dynamic]

-dcmm-lint

C-- pass sanity checking [dynamic]

-dstg-lint

STG pass sanity checking [dynamic]

-dstg-stats

Dump STG stats [dynamic]

-dverbose-core2core

Show output from each core-to-core pass [dynamic]

-dverbose-stg2stg

Show output from each STG-to-STG pass [dynamic]

-dshow-passes

Print out each pass name as it happens [dynamic]

-dfaststring-stats

Show statistics for fast string usage when finished [dynamic]

MISC COMPILER OPTIONS

-fno-hi-version-check

Don't complain about .hi file mismatches [static]

-dno-black-holing

Turn off black holing (probably doesn't work) [static]

-fhistory-size

Set simplification history size [static]

-funregisterised

Unregisterised compilation (use -unreg instead) [static]

-fno-asm-mangling

Turn off assembly mangling (use -unreg instead) [dynamic]

FILES

COPYRIGHT

Copyright 2002, The University Court of the University of Glasgow.
All rights reserved.

AUTHOR

This manual page was generated from the XML documentation of GHC with blood, sweat, tears and a breaks-if-you-look-at-it-the-wrong-way XSL stylesheet originally written by Michael Weber <michaelw@debian.org> for the Debian GNU/Linux system (but may be used by others).