2d4b4e9d78b05484271986419736bdfc5f2d7ac4
[ghc-hetmet.git] / ghc / compiler / main / CmdLineOpts.lhs
1
2 % (c) The University of Glasgow, 1996-2000
3 %
4 \section[CmdLineOpts]{Things to do with command-line options}
5
6 \begin{code}
7
8 module CmdLineOpts (
9         CoreToDo(..), buildCoreToDo, StgToDo(..),
10         SimplifierSwitch(..), 
11         SimplifierMode(..), FloatOutSwitches(..),
12
13         HscTarget(..),
14         DynFlag(..),    -- needed non-abstractly by DriverFlags
15         DynFlags(..),
16         PackageFlag(..),
17
18         v_Static_hsc_opts,
19
20         isStaticHscFlag,
21
22         -- Manipulating DynFlags
23         defaultDynFlags,                -- DynFlags
24         dopt,                           -- DynFlag -> DynFlags -> Bool
25         dopt_set, dopt_unset,           -- DynFlags -> DynFlag -> DynFlags
26         dopt_CoreToDo,                  -- DynFlags -> [CoreToDo]
27         dopt_StgToDo,                   -- DynFlags -> [StgToDo]
28         dopt_HscTarget,                 -- DynFlags -> HscTarget
29         dopt_OutName,                   -- DynFlags -> String
30         getOpts,                        -- (DynFlags -> [a]) -> IO [a]
31         getVerbFlag,
32         updOptLevel,
33
34         -- sets of warning opts
35         minusWOpts,
36         minusWallOpts,
37
38         -- Output style options
39         opt_PprUserLength,
40         opt_PprStyle_Debug,
41
42         -- profiling opts
43         opt_AutoSccsOnAllToplevs,
44         opt_AutoSccsOnExportedToplevs,
45         opt_AutoSccsOnIndividualCafs,
46         opt_SccProfilingOn,
47         opt_DoTickyProfiling,
48
49         -- language opts
50         opt_DictsStrict,
51         opt_MaxContextReductionDepth,
52         opt_IrrefutableTuples,
53         opt_Parallel,
54         opt_SMP,
55         opt_RuntimeTypes,
56         opt_Flatten,
57
58         -- optimisation opts
59         opt_NoMethodSharing, 
60         opt_NoStateHack,
61         opt_LiberateCaseThreshold,
62         opt_CprOff,
63         opt_RulesOff,
64         opt_SimplNoPreInlining,
65         opt_SimplExcessPrecision,
66         opt_MaxWorkerArgs,
67
68         -- Unfolding control
69         opt_UF_CreationThreshold,
70         opt_UF_UseThreshold,
71         opt_UF_FunAppDiscount,
72         opt_UF_KeenessFactor,
73         opt_UF_UpdateInPlace,
74         opt_UF_DearOp,
75
76         -- misc opts
77         opt_ErrorSpans,
78         opt_EmitCExternDecls,
79         opt_EnsureSplittableC,
80         opt_GranMacros,
81         opt_HiVersion,
82         opt_HistorySize,
83         opt_OmitBlackHoling,
84         opt_Static,
85         opt_Unregisterised,
86         opt_EmitExternalCore,
87         opt_PIC
88     ) where
89
90 #include "HsVersions.h"
91
92 import {-# SOURCE #-} Packages (PackageState)
93 import DriverPhases     ( HscTarget(..) )
94 import Constants        -- Default values for some flags
95 import Util
96 import FastString       ( FastString, mkFastString )
97 import Config
98 import Maybes           ( firstJust )
99
100 import Panic            ( ghcError, GhcException(UsageError) )
101 import GLAEXTS
102 import DATA_IOREF       ( IORef, readIORef )
103 import UNSAFE_IO        ( unsafePerformIO )
104 \end{code}
105
106 %************************************************************************
107 %*                                                                      *
108 \subsection{Command-line options}
109 %*                                                                      *
110 %************************************************************************
111
112 The hsc command-line options are split into two categories:
113
114   - static flags
115   - dynamic flags
116
117 Static flags are represented by top-level values of type Bool or Int,
118 for example.  They therefore have the same value throughout the
119 invocation of hsc.
120
121 Dynamic flags are represented by an abstract type, DynFlags, which is
122 passed into hsc by the compilation manager for every compilation.
123 Dynamic flags are those that change on a per-compilation basis,
124 perhaps because they may be present in the OPTIONS pragma at the top
125 of a module.
126
127 Other flag-related blurb:
128
129 A list of {\em ToDo}s is things to be done in a particular part of
130 processing.  A (fictitious) example for the Core-to-Core simplifier
131 might be: run the simplifier, then run the strictness analyser, then
132 run the simplifier again (three ``todos'').
133
134 There are three ``to-do processing centers'' at the moment.  In the
135 main loop (\tr{main/Main.lhs}), in the Core-to-Core processing loop
136 (\tr{simplCore/SimplCore.lhs), and in the STG-to-STG processing loop
137 (\tr{simplStg/SimplStg.lhs}).
138
139 %************************************************************************
140 %*                                                                      *
141 \subsection{Datatypes associated with command-line options}
142 %*                                                                      *
143 %************************************************************************
144
145 \begin{code}
146 data CoreToDo           -- These are diff core-to-core passes,
147                         -- which may be invoked in any order,
148                         -- as many times as you like.
149
150   = CoreDoSimplify      -- The core-to-core simplifier.
151         SimplifierMode
152         [SimplifierSwitch]
153                         -- Each run of the simplifier can take a different
154                         -- set of simplifier-specific flags.
155   | CoreDoFloatInwards
156   | CoreDoFloatOutwards FloatOutSwitches
157   | CoreLiberateCase
158   | CoreDoPrintCore
159   | CoreDoStaticArgs
160   | CoreDoStrictness
161   | CoreDoWorkerWrapper
162   | CoreDoSpecialising
163   | CoreDoSpecConstr
164   | CoreDoOldStrictness
165   | CoreDoGlomBinds
166   | CoreCSE
167   | CoreDoRuleCheck Int{-CompilerPhase-} String -- Check for non-application of rules 
168                                                 -- matching this string
169
170   | CoreDoNothing        -- useful when building up lists of these things
171 \end{code}
172
173 \begin{code}
174 data StgToDo
175   = StgDoMassageForProfiling  -- should be (next to) last
176   -- There's also setStgVarInfo, but its absolute "lastness"
177   -- is so critical that it is hardwired in (no flag).
178   | D_stg_stats
179 \end{code}
180
181 \begin{code}
182 data SimplifierMode             -- See comments in SimplMonad
183   = SimplGently
184   | SimplPhase Int
185
186 data SimplifierSwitch
187   = MaxSimplifierIterations Int
188   | NoCaseOfCase
189
190 data FloatOutSwitches
191   = FloatOutSw  Bool    -- True <=> float lambdas to top level
192                 Bool    -- True <=> float constants to top level,
193                         --          even if they do not escape a lambda
194 \end{code}
195
196 %************************************************************************
197 %*                                                                      *
198 \subsection{Dynamic command-line options}
199 %*                                                                      *
200 %************************************************************************
201
202 \begin{code}
203 data DynFlag
204
205    -- debugging flags
206    = Opt_D_dump_cmm
207    | Opt_D_dump_asm
208    | Opt_D_dump_cpranal
209    | Opt_D_dump_deriv
210    | Opt_D_dump_ds
211    | Opt_D_dump_flatC
212    | Opt_D_dump_foreign
213    | Opt_D_dump_inlinings
214    | Opt_D_dump_occur_anal
215    | Opt_D_dump_parsed
216    | Opt_D_dump_rn
217    | Opt_D_dump_simpl
218    | Opt_D_dump_simpl_iterations
219    | Opt_D_dump_spec
220    | Opt_D_dump_prep
221    | Opt_D_dump_stg
222    | Opt_D_dump_stranal
223    | Opt_D_dump_tc
224    | Opt_D_dump_types
225    | Opt_D_dump_rules
226    | Opt_D_dump_cse
227    | Opt_D_dump_worker_wrapper
228    | Opt_D_dump_rn_trace
229    | Opt_D_dump_rn_stats
230    | Opt_D_dump_opt_cmm
231    | Opt_D_dump_simpl_stats
232    | Opt_D_dump_tc_trace
233    | Opt_D_dump_if_trace
234    | Opt_D_dump_splices
235    | Opt_D_dump_BCOs
236    | Opt_D_dump_vect
237    | Opt_D_source_stats
238    | Opt_D_verbose_core2core
239    | Opt_D_verbose_stg2stg
240    | Opt_D_dump_hi
241    | Opt_D_dump_hi_diffs
242    | Opt_D_dump_minimal_imports
243    | Opt_DoCoreLinting
244    | Opt_DoStgLinting
245    | Opt_DoCmmLinting
246
247    | Opt_WarnIsError            -- -Werror; makes warnings fatal
248    | Opt_WarnDuplicateExports
249    | Opt_WarnHiShadows
250    | Opt_WarnIncompletePatterns
251    | Opt_WarnIncompletePatternsRecUpd
252    | Opt_WarnMissingFields
253    | Opt_WarnMissingMethods
254    | Opt_WarnMissingSigs
255    | Opt_WarnNameShadowing
256    | Opt_WarnOverlappingPatterns
257    | Opt_WarnSimplePatterns
258    | Opt_WarnTypeDefaults
259    | Opt_WarnUnusedBinds
260    | Opt_WarnUnusedImports
261    | Opt_WarnUnusedMatches
262    | Opt_WarnDeprecations
263    | Opt_WarnDodgyImports
264    | Opt_WarnOrphans
265
266    -- language opts
267    | Opt_AllowOverlappingInstances
268    | Opt_AllowUndecidableInstances
269    | Opt_AllowIncoherentInstances
270    | Opt_MonomorphismRestriction
271    | Opt_GlasgowExts
272    | Opt_FFI
273    | Opt_PArr                          -- syntactic support for parallel arrays
274    | Opt_Arrows                        -- Arrow-notation syntax
275    | Opt_TH
276    | Opt_ImplicitParams
277    | Opt_Generics
278    | Opt_ImplicitPrelude 
279    | Opt_ScopedTypeVariables
280
281    -- optimisation opts
282    | Opt_Strictness
283    | Opt_FullLaziness
284    | Opt_CSE
285    | Opt_IgnoreInterfacePragmas
286    | Opt_OmitInterfacePragmas
287    | Opt_DoLambdaEtaExpansion
288    | Opt_IgnoreAsserts
289    | Opt_DoEtaReduction
290    | Opt_CaseMerge
291    | Opt_UnboxStrictFields
292
293    deriving (Eq)
294
295 data DynFlags = DynFlags {
296   coreToDo              :: Maybe [CoreToDo], -- reserved for use with -Ofile
297   stgToDo               :: [StgToDo],
298   hscTarget             :: HscTarget,
299   hscOutName            :: String,      -- name of the output file
300   hscStubHOutName       :: String,      -- name of the .stub_h output file
301   hscStubCOutName       :: String,      -- name of the .stub_c output file
302   extCoreName           :: String,      -- name of the .core output file
303   verbosity             :: Int,         -- verbosity level
304   optLevel              :: Int,         -- optimisation level
305   maxSimplIterations    :: Int,         -- max simplifier iterations
306   ruleCheck             :: Maybe String,
307   cppFlag               :: Bool,        -- preprocess with cpp?
308   ppFlag                :: Bool,        -- preprocess with a Haskell Pp?
309   recompFlag            :: Bool,        -- True <=> recompilation checker is on
310   stolen_x86_regs       :: Int,         
311   cmdlineHcIncludes     :: [String],    -- -#includes
312   importPaths           :: [FilePath],
313
314   -- options for particular phases
315   opt_L                 :: [String],
316   opt_P                 :: [String],
317   opt_F                 :: [String],
318   opt_c                 :: [String],
319   opt_a                 :: [String],
320   opt_m                 :: [String],
321 #ifdef ILX                         
322   opt_I                 :: [String],
323   opt_i                 :: [String],
324 #endif
325
326   -- ** Package flags
327   extraPkgConfs         :: [FilePath],
328         -- The -package-conf flags given on the command line, in the order
329         -- they appeared.
330
331   readUserPkgConf       :: Bool,
332         -- Whether or not to read the user package database
333         -- (-no-user-package-conf).
334
335   packageFlags          :: [PackageFlag],
336         -- The -package and -hide-package flags from the command-line
337
338   -- ** Package state
339   pkgState              :: PackageState,
340
341   -- hsc dynamic flags
342   flags                 :: [DynFlag]
343  }
344
345 data PackageFlag
346   = ExposePackage  String
347   | HidePackage    String
348   | IgnorePackage  String
349
350 defaultHscTarget
351 #if defined(i386_TARGET_ARCH) || defined(sparc_TARGET_ARCH) || defined(powerpc_TARGET_ARCH)
352   | cGhcWithNativeCodeGen == "YES"      =  HscAsm
353 #endif
354   | otherwise                           =  HscC
355
356 defaultDynFlags = DynFlags {
357   coreToDo = Nothing, stgToDo = [], 
358   hscTarget = defaultHscTarget, 
359   hscOutName = "", 
360   hscStubHOutName = "", hscStubCOutName = "",
361   extCoreName = "",
362   verbosity             = 0, 
363   optLevel              = 0,
364   maxSimplIterations    = 4,
365   ruleCheck             = Nothing,
366   cppFlag               = False,
367   ppFlag                = False,
368   recompFlag            = True,
369   stolen_x86_regs       = 4,
370   cmdlineHcIncludes     = [],
371   importPaths           = ["."],
372   opt_L                 = [],
373   opt_P                 = [],
374   opt_F                 = [],
375   opt_c                 = [],
376   opt_a                 = [],
377   opt_m                 = [],
378 #ifdef ILX
379   opt_I                 = [],
380   opt_i                 = [],
381 #endif
382
383   extraPkgConfs         = [],
384   readUserPkgConf       = True,
385   packageFlags          = [],
386   pkgState              = error "pkgState",
387
388   flags = [ 
389             Opt_ImplicitPrelude,
390             Opt_MonomorphismRestriction,
391             Opt_Generics,
392                         -- Generating the helper-functions for
393                         -- generics is now on by default
394             Opt_Strictness,
395                         -- strictness is on by default, but this only
396                         -- applies to -O.
397             Opt_CSE,            -- similarly for CSE.
398             Opt_FullLaziness,   -- ...and for full laziness
399
400             Opt_DoLambdaEtaExpansion,
401                         -- This one is important for a tiresome reason:
402                         -- we want to make sure that the bindings for data 
403                         -- constructors are eta-expanded.  This is probably
404                         -- a good thing anyway, but it seems fragile.
405
406             -- and the default no-optimisation options:
407             Opt_IgnoreInterfacePragmas,
408             Opt_OmitInterfacePragmas
409
410            ] ++ standardWarnings
411   }
412
413 {- 
414     Verbosity levels:
415         
416     0   |   print errors & warnings only
417     1   |   minimal verbosity: print "compiling M ... done." for each module.
418     2   |   equivalent to -dshow-passes
419     3   |   equivalent to existing "ghc -v"
420     4   |   "ghc -v -ddump-most"
421     5   |   "ghc -v -ddump-all"
422 -}
423
424 dopt :: DynFlag -> DynFlags -> Bool
425 dopt f dflags  = f `elem` (flags dflags)
426
427 dopt_CoreToDo :: DynFlags -> Maybe [CoreToDo]
428 dopt_CoreToDo = coreToDo
429
430 dopt_StgToDo :: DynFlags -> [StgToDo]
431 dopt_StgToDo = stgToDo
432
433 dopt_OutName :: DynFlags -> String
434 dopt_OutName = hscOutName
435
436 dopt_HscTarget :: DynFlags -> HscTarget
437 dopt_HscTarget = hscTarget
438
439 dopt_set :: DynFlags -> DynFlag -> DynFlags
440 dopt_set dfs f = dfs{ flags = f : flags dfs }
441
442 dopt_unset :: DynFlags -> DynFlag -> DynFlags
443 dopt_unset dfs f = dfs{ flags = filter (/= f) (flags dfs) }
444
445 getOpts :: DynFlags -> (DynFlags -> [a]) -> [a]
446         -- We add to the options from the front, so we need to reverse the list
447 getOpts dflags opts = reverse (opts dflags)
448
449 getVerbFlag dflags 
450   | verbosity dflags >= 3  = "-v" 
451   | otherwise =  ""
452
453 -----------------------------------------------------------------------------
454 -- Setting the optimisation level
455
456 updOptLevel n dfs
457   = if (n >= 1)
458      then dfs2{ hscTarget = HscC, optLevel = n } -- turn on -fvia-C with -O
459      else dfs2{ optLevel = n }
460   where
461    dfs1 = foldr (flip dopt_unset) dfs  remove_dopts
462    dfs2 = foldr (flip dopt_set)   dfs1 extra_dopts
463
464    extra_dopts
465         | n == 0    = opt_0_dopts
466         | otherwise = opt_1_dopts
467
468    remove_dopts
469         | n == 0    = opt_1_dopts
470         | otherwise = opt_0_dopts
471         
472 opt_0_dopts =  [ 
473         Opt_IgnoreInterfacePragmas,
474         Opt_OmitInterfacePragmas
475     ]
476
477 opt_1_dopts = [
478         Opt_IgnoreAsserts,
479         Opt_DoEtaReduction,
480         Opt_CaseMerge
481      ]
482
483 -- Core-to-core phases:
484
485 buildCoreToDo :: DynFlags -> [CoreToDo]
486 buildCoreToDo dflags = core_todo
487   where
488     opt_level     = optLevel dflags
489     max_iter      = maxSimplIterations dflags
490     strictness    = dopt Opt_Strictness dflags
491     full_laziness = dopt Opt_FullLaziness dflags
492     cse           = dopt Opt_CSE dflags
493     rule_check    = ruleCheck dflags
494
495     core_todo = 
496      if opt_level == 0 then
497       [
498         CoreDoSimplify (SimplPhase 0) [
499             MaxSimplifierIterations max_iter
500         ]
501       ]
502
503      else {- opt_level >= 1 -} [ 
504
505         -- initial simplify: mk specialiser happy: minimum effort please
506         CoreDoSimplify SimplGently [
507                         --      Simplify "gently"
508                         -- Don't inline anything till full laziness has bitten
509                         -- In particular, inlining wrappers inhibits floating
510                         -- e.g. ...(case f x of ...)...
511                         --  ==> ...(case (case x of I# x# -> fw x#) of ...)...
512                         --  ==> ...(case x of I# x# -> case fw x# of ...)...
513                         -- and now the redex (f x) isn't floatable any more
514                         -- Similarly, don't apply any rules until after full 
515                         -- laziness.  Notably, list fusion can prevent floating.
516
517             NoCaseOfCase,
518                         -- Don't do case-of-case transformations.
519                         -- This makes full laziness work better
520             MaxSimplifierIterations max_iter
521         ],
522
523         -- Specialisation is best done before full laziness
524         -- so that overloaded functions have all their dictionary lambdas manifest
525         CoreDoSpecialising,
526
527         if full_laziness then CoreDoFloatOutwards (FloatOutSw False False)
528                          else CoreDoNothing,
529
530         CoreDoFloatInwards,
531
532         CoreDoSimplify (SimplPhase 2) [
533                 -- Want to run with inline phase 2 after the specialiser to give
534                 -- maximum chance for fusion to work before we inline build/augment
535                 -- in phase 1.  This made a difference in 'ansi' where an 
536                 -- overloaded function wasn't inlined till too late.
537            MaxSimplifierIterations max_iter
538         ],
539         case rule_check of { Just pat -> CoreDoRuleCheck 2 pat; Nothing -> CoreDoNothing },
540
541         CoreDoSimplify (SimplPhase 1) [
542                 -- Need inline-phase2 here so that build/augment get 
543                 -- inlined.  I found that spectral/hartel/genfft lost some useful
544                 -- strictness in the function sumcode' if augment is not inlined
545                 -- before strictness analysis runs
546            MaxSimplifierIterations max_iter
547         ],
548         case rule_check of { Just pat -> CoreDoRuleCheck 1 pat; Nothing -> CoreDoNothing },
549
550         CoreDoSimplify (SimplPhase 0) [
551                 -- Phase 0: allow all Ids to be inlined now
552                 -- This gets foldr inlined before strictness analysis
553
554            MaxSimplifierIterations 3
555                 -- At least 3 iterations because otherwise we land up with
556                 -- huge dead expressions because of an infelicity in the 
557                 -- simpifier.   
558                 --      let k = BIG in foldr k z xs
559                 -- ==>  let k = BIG in letrec go = \xs -> ...(k x).... in go xs
560                 -- ==>  let k = BIG in letrec go = \xs -> ...(BIG x).... in go xs
561                 -- Don't stop now!
562
563         ],
564         case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
565
566 #ifdef OLD_STRICTNESS
567         CoreDoOldStrictness
568 #endif
569         if strictness then CoreDoStrictness else CoreDoNothing,
570         CoreDoWorkerWrapper,
571         CoreDoGlomBinds,
572
573         CoreDoSimplify (SimplPhase 0) [
574            MaxSimplifierIterations max_iter
575         ],
576
577         if full_laziness then
578           CoreDoFloatOutwards (FloatOutSw False   -- Not lambdas
579                                           True)   -- Float constants
580         else CoreDoNothing,
581                 -- nofib/spectral/hartel/wang doubles in speed if you
582                 -- do full laziness late in the day.  It only happens
583                 -- after fusion and other stuff, so the early pass doesn't
584                 -- catch it.  For the record, the redex is 
585                 --        f_el22 (f_el21 r_midblock)
586
587
588         -- We want CSE to follow the final full-laziness pass, because it may
589         -- succeed in commoning up things floated out by full laziness.
590         -- CSE used to rely on the no-shadowing invariant, but it doesn't any more
591
592         if cse then CoreCSE else CoreDoNothing,
593
594         CoreDoFloatInwards,
595
596 -- Case-liberation for -O2.  This should be after
597 -- strictness analysis and the simplification which follows it.
598
599         case rule_check of { Just pat -> CoreDoRuleCheck 0 pat; Nothing -> CoreDoNothing },
600
601         if opt_level >= 2 then
602            CoreLiberateCase
603         else
604            CoreDoNothing,
605         if opt_level >= 2 then
606            CoreDoSpecConstr
607         else
608            CoreDoNothing,
609
610         -- Final clean-up simplification:
611         CoreDoSimplify (SimplPhase 0) [
612           MaxSimplifierIterations max_iter
613         ]
614      ]
615 \end{code}
616
617 %************************************************************************
618 %*                                                                      *
619 \subsection{Warnings}
620 %*                                                                      *
621 %************************************************************************
622
623 \begin{code}
624 standardWarnings
625     = [ Opt_WarnDeprecations,
626         Opt_WarnOverlappingPatterns,
627         Opt_WarnMissingFields,
628         Opt_WarnMissingMethods,
629         Opt_WarnDuplicateExports
630       ]
631
632 minusWOpts
633     = standardWarnings ++ 
634       [ Opt_WarnUnusedBinds,
635         Opt_WarnUnusedMatches,
636         Opt_WarnUnusedImports,
637         Opt_WarnIncompletePatterns,
638         Opt_WarnDodgyImports
639       ]
640
641 minusWallOpts
642     = minusWOpts ++
643       [ Opt_WarnTypeDefaults,
644         Opt_WarnNameShadowing,
645         Opt_WarnMissingSigs,
646         Opt_WarnHiShadows,
647         Opt_WarnOrphans
648       ]
649 \end{code}
650
651 %************************************************************************
652 %*                                                                      *
653 \subsection{Classifying command-line options}
654 %*                                                                      *
655 %************************************************************************
656
657 \begin{code}
658 -- v_Statis_hsc_opts is here to avoid a circular dependency with
659 -- main/DriverState.
660 GLOBAL_VAR(v_Static_hsc_opts, [], [String])
661
662 lookUp           :: FastString -> Bool
663 lookup_def_int   :: String -> Int -> Int
664 lookup_def_float :: String -> Float -> Float
665 lookup_str       :: String -> Maybe String
666
667 unpacked_static_opts = unsafePerformIO (readIORef v_Static_hsc_opts)
668 packed_static_opts   = map mkFastString unpacked_static_opts
669
670 lookUp     sw = sw `elem` packed_static_opts
671         
672 -- (lookup_str "foo") looks for the flag -foo=X or -fooX, 
673 -- and returns the string X
674 lookup_str sw 
675    = case firstJust (map (startsWith sw) unpacked_static_opts) of
676         Just ('=' : str) -> Just str
677         Just str         -> Just str
678         Nothing          -> Nothing     
679
680 lookup_def_int sw def = case (lookup_str sw) of
681                             Nothing -> def              -- Use default
682                             Just xx -> try_read sw xx
683
684 lookup_def_float sw def = case (lookup_str sw) of
685                             Nothing -> def              -- Use default
686                             Just xx -> try_read sw xx
687
688
689 try_read :: Read a => String -> String -> a
690 -- (try_read sw str) tries to read s; if it fails, it
691 -- bleats about flag sw
692 try_read sw str
693   = case reads str of
694         ((x,_):_) -> x  -- Be forgiving: ignore trailing goop, and alternative parses
695         []        -> ghcError (UsageError ("Malformed argument " ++ str ++ " for flag " ++ sw))
696                         -- ToDo: hack alert. We should really parse the arugments
697                         --       and announce errors in a more civilised way.
698
699
700 {-
701  Putting the compiler options into temporary at-files
702  may turn out to be necessary later on if we turn hsc into
703  a pure Win32 application where I think there's a command-line
704  length limit of 255. unpacked_opts understands the @ option.
705
706 unpacked_opts :: [String]
707 unpacked_opts =
708   concat $
709   map (expandAts) $
710   map unpackFS argv  -- NOT ARGV any more: v_Static_hsc_opts
711   where
712    expandAts ('@':fname) = words (unsafePerformIO (readFile fname))
713    expandAts l = [l]
714 -}
715 \end{code}
716
717 %************************************************************************
718 %*                                                                      *
719 \subsection{Static options}
720 %*                                                                      *
721 %************************************************************************
722
723 \begin{code}
724 -- debugging opts
725 opt_PprStyle_Debug              = lookUp  FSLIT("-dppr-debug")
726 opt_PprUserLength               = lookup_def_int "-dppr-user-length" 5 --ToDo: give this a name
727
728 -- profiling opts
729 opt_AutoSccsOnAllToplevs        = lookUp  FSLIT("-fauto-sccs-on-all-toplevs")
730 opt_AutoSccsOnExportedToplevs   = lookUp  FSLIT("-fauto-sccs-on-exported-toplevs")
731 opt_AutoSccsOnIndividualCafs    = lookUp  FSLIT("-fauto-sccs-on-individual-cafs")
732 opt_SccProfilingOn              = lookUp  FSLIT("-fscc-profiling")
733 opt_DoTickyProfiling            = lookUp  FSLIT("-fticky-ticky")
734
735 -- language opts
736 opt_DictsStrict                 = lookUp  FSLIT("-fdicts-strict")
737 opt_IrrefutableTuples           = lookUp  FSLIT("-firrefutable-tuples")
738 opt_MaxContextReductionDepth    = lookup_def_int "-fcontext-stack" mAX_CONTEXT_REDUCTION_DEPTH
739 opt_Parallel                    = lookUp  FSLIT("-fparallel")
740 opt_SMP                         = lookUp  FSLIT("-fsmp")
741 opt_Flatten                     = lookUp  FSLIT("-fflatten")
742
743 -- optimisation opts
744 opt_NoStateHack                 = lookUp  FSLIT("-fno-state-hack")
745 opt_NoMethodSharing             = lookUp  FSLIT("-fno-method-sharing")
746 opt_CprOff                      = lookUp  FSLIT("-fcpr-off")
747 opt_RulesOff                    = lookUp  FSLIT("-frules-off")
748         -- Switch off CPR analysis in the new demand analyser
749 opt_LiberateCaseThreshold       = lookup_def_int "-fliberate-case-threshold" (10::Int)
750 opt_MaxWorkerArgs               = lookup_def_int "-fmax-worker-args" (10::Int)
751
752 opt_EmitCExternDecls            = lookUp  FSLIT("-femit-extern-decls")
753 opt_EnsureSplittableC           = lookUp  FSLIT("-fglobalise-toplev-names")
754 opt_GranMacros                  = lookUp  FSLIT("-fgransim")
755 opt_HiVersion                   = read (cProjectVersionInt ++ cProjectPatchLevel) :: Int
756 opt_HistorySize                 = lookup_def_int "-fhistory-size" 20
757 opt_OmitBlackHoling             = lookUp  FSLIT("-dno-black-holing")
758 opt_RuntimeTypes                = lookUp  FSLIT("-fruntime-types")
759
760 -- Simplifier switches
761 opt_SimplNoPreInlining          = lookUp  FSLIT("-fno-pre-inlining")
762         -- NoPreInlining is there just to see how bad things
763         -- get if you don't do it!
764 opt_SimplExcessPrecision        = lookUp  FSLIT("-fexcess-precision")
765
766 -- Unfolding control
767 opt_UF_CreationThreshold        = lookup_def_int "-funfolding-creation-threshold"  (45::Int)
768 opt_UF_UseThreshold             = lookup_def_int "-funfolding-use-threshold"       (8::Int)     -- Discounts can be big
769 opt_UF_FunAppDiscount           = lookup_def_int "-funfolding-fun-discount"        (6::Int)     -- It's great to inline a fn
770 opt_UF_KeenessFactor            = lookup_def_float "-funfolding-keeness-factor"    (1.5::Float)
771 opt_UF_UpdateInPlace            = lookUp  FSLIT("-funfolding-update-in-place")
772
773 opt_UF_DearOp   = ( 4 :: Int)
774                         
775 opt_Static                      = lookUp  FSLIT("-static")
776 opt_Unregisterised              = lookUp  FSLIT("-funregisterised")
777 opt_EmitExternalCore            = lookUp  FSLIT("-fext-core")
778
779 -- Include full span info in error messages, instead of just the start position.
780 opt_ErrorSpans                  = lookUp FSLIT("-ferror-spans")
781
782 opt_PIC                         = lookUp FSLIT("-fPIC")
783 \end{code}
784
785 %************************************************************************
786 %*                                                                      *
787 \subsection{List of static hsc flags}
788 %*                                                                      *
789 %************************************************************************
790
791 \begin{code}
792 isStaticHscFlag f =
793   f `elem` [
794         "fauto-sccs-on-all-toplevs",
795         "fauto-sccs-on-exported-toplevs",
796         "fauto-sccs-on-individual-cafs",
797         "fauto-sccs-on-dicts",
798         "fscc-profiling",
799         "fticky-ticky",
800         "fall-strict",
801         "fdicts-strict",
802         "firrefutable-tuples",
803         "fparallel",
804         "fsmp",
805         "fflatten",
806         "fsemi-tagging",
807         "flet-no-escape",
808         "femit-extern-decls",
809         "fglobalise-toplev-names",
810         "fgransim",
811         "fno-hi-version-check",
812         "dno-black-holing",
813         "fno-method-sharing",
814         "fno-state-hack",
815         "fruntime-types",
816         "fno-pre-inlining",
817         "fexcess-precision",
818         "funfolding-update-in-place",
819         "static",
820         "funregisterised",
821         "fext-core",
822         "frule-check",
823         "frules-off",
824         "fcpr-off",
825         "ferror-spans",
826         "fPIC"
827         ]
828   || any (flip prefixMatch f) [
829         "fcontext-stack",
830         "fliberate-case-threshold",
831         "fmax-worker-args",
832         "fhistory-size",
833         "funfolding-creation-threshold",
834         "funfolding-use-threshold",
835         "funfolding-fun-discount",
836         "funfolding-keeness-factor"
837      ]
838 \end{code}
839
840 %************************************************************************
841 %*                                                                      *
842 \subsection{Misc functions for command-line options}
843 %*                                                                      *
844 %************************************************************************
845
846
847
848 \begin{code}
849 startsWith :: String -> String -> Maybe String
850 -- startsWith pfx (pfx++rest) = Just rest
851
852 startsWith []     str = Just str
853 startsWith (c:cs) (s:ss)
854   = if c /= s then Nothing else startsWith cs ss
855 startsWith  _     []  = Nothing
856 \end{code}