| otherwise
= case ghcLink dflags of
NoLink -> return ()
- LinkBinary -> linkBinary dflags o_files link_pkgs
+ LinkBinary -> linkBinary dflags o_files []
LinkDynLib -> linkDynLib dflags o_files []
other -> panicBadLink other
- where
- -- Always link in the haskell98 package for static linking. Other
- -- packages have to be specified via the -package flag.
- link_pkgs
- | dopt Opt_AutoLinkPackages dflags = [haskell98PackageId]
- | otherwise = []
-- ---------------------------------------------------------------------------
runPhase (Cpp sf) _stop hsc_env _basename _suff input_fn get_output_fn maybe_loc
= do let dflags0 = hsc_dflags hsc_env
- let dflags0' = flattenExtensionFlags dflags0
- src_opts <- liftIO $ getOptionsFromFile dflags0' input_fn
+ src_opts <- liftIO $ getOptionsFromFile dflags0 input_fn
(dflags1, unhandled_flags, warns)
<- liftIO $ parseDynamicNoPackageFlags dflags0 src_opts
checkProcessArgsResult unhandled_flags
- let dflags1' = flattenExtensionFlags dflags1
- if not (dopt Opt_Cpp dflags1') then do
+ if not (xopt Opt_Cpp dflags1) then do
-- we have to be careful to emit warnings only once.
- unless (dopt Opt_Pp dflags1') $ handleFlagWarnings dflags1' warns
+ unless (dopt Opt_Pp dflags1) $ handleFlagWarnings dflags1 warns
-- no need to preprocess CPP, just pass input file along
-- to the next phase of the pipeline.
return (HsPp sf, dflags1, maybe_loc, input_fn)
else do
- output_fn <- liftIO $ get_output_fn dflags1' (HsPp sf) maybe_loc
- liftIO $ doCpp dflags1' True{-raw-} False{-no CC opts-} input_fn output_fn
+ output_fn <- liftIO $ get_output_fn dflags1 (HsPp sf) maybe_loc
+ liftIO $ doCpp dflags1 True{-raw-} False{-no CC opts-} input_fn output_fn
-- re-read the pragmas now that we've preprocessed the file
-- See #2464,#3457
- src_opts <- liftIO $ getOptionsFromFile dflags0' output_fn
+ src_opts <- liftIO $ getOptionsFromFile dflags0 output_fn
(dflags2, unhandled_flags, warns)
<- liftIO $ parseDynamicNoPackageFlags dflags0 src_opts
- let dflags2' = flattenExtensionFlags dflags2
- unless (dopt Opt_Pp dflags2') $ handleFlagWarnings dflags2' warns
+ unless (dopt Opt_Pp dflags2) $ handleFlagWarnings dflags2 warns
-- the HsPp pass below will emit warnings
checkProcessArgsResult unhandled_flags
runPhase (HsPp sf) _stop hsc_env basename suff input_fn get_output_fn maybe_loc
= do let dflags = hsc_dflags hsc_env
- dflags' = flattenExtensionFlags dflags
if not (dopt Opt_Pp dflags) then
-- no need to preprocess, just pass input file along
-- to the next phase of the pipeline.
- return (Hsc sf, dflags', maybe_loc, input_fn)
+ return (Hsc sf, dflags, maybe_loc, input_fn)
else do
let hspp_opts = getOpts dflags opt_F
let orig_fn = basename <.> suff
)
-- re-read pragmas now that we've parsed the file (see #3674)
- src_opts <- liftIO $ getOptionsFromFile dflags' output_fn
+ src_opts <- liftIO $ getOptionsFromFile dflags output_fn
(dflags1, unhandled_flags, warns)
<- liftIO $ parseDynamicNoPackageFlags dflags src_opts
- let dflags1' = flattenExtensionFlags dflags1
- handleFlagWarnings dflags1' warns
+ handleFlagWarnings dflags1 warns
checkProcessArgsResult unhandled_flags
- return (Hsc sf, dflags1', maybe_loc, output_fn)
+ return (Hsc sf, dflags1, maybe_loc, output_fn)
-----------------------------------------------------------------------------
-- Hsc phase
runPhase CmmCpp _stop hsc_env _basename _suff input_fn get_output_fn maybe_loc
= do
let dflags = hsc_dflags hsc_env
- dflags' = flattenExtensionFlags dflags
- output_fn <- liftIO $ get_output_fn dflags' Cmm maybe_loc
- liftIO $ doCpp dflags' False{-not raw-} True{-include CC opts-} input_fn output_fn
- return (Cmm, dflags', maybe_loc, output_fn)
+ output_fn <- liftIO $ get_output_fn dflags Cmm maybe_loc
+ liftIO $ doCpp dflags False{-not raw-} True{-include CC opts-} input_fn output_fn
+ return (Cmm, dflags, maybe_loc, output_fn)
runPhase Cmm stop hsc_env basename _ input_fn get_output_fn maybe_loc
= do
- let dflags = ensureFlattenedExtensionFlags $ hsc_dflags hsc_env
+ let dflags = hsc_dflags hsc_env
let hsc_lang = hscMaybeAdjustTarget dflags stop HsSrcFile (hscTarget dflags)
let next_phase = hscNextPhase dflags HsSrcFile hsc_lang
output_fn <- liftIO $ get_output_fn dflags next_phase maybe_loc
-- we don't need the generality of a phase (MoveBinary is always
-- done after linking and makes only sense in a parallel setup) -- HWL
-runPhase_MoveBinary :: DynFlags -> FilePath -> [PackageId] -> IO Bool
-runPhase_MoveBinary dflags input_fn dep_packages
+runPhase_MoveBinary :: DynFlags -> FilePath -> IO Bool
+runPhase_MoveBinary dflags input_fn
| WayPar `elem` (wayNames dflags) && not opt_Static =
panic ("Don't know how to combine PVM wrapper and dynamic wrapper")
| WayPar `elem` (wayNames dflags) = do
-- generate a wrapper script for running a parallel prg under PVM
writeFile input_fn (mk_pvm_wrapper_script pvm_executable pvm_executable_base sysMan)
return True
- | not opt_Static =
- case (dynLibLoader dflags) of
- Wrapped wrapmode ->
- do
- let (o_base, o_ext) = splitExtension input_fn
- let wrapped_executable | o_ext == "exe" = (o_base ++ ".dyn") <.> o_ext
- | otherwise = input_fn ++ ".dyn"
- behaviour <- wrapper_behaviour dflags wrapmode dep_packages
-
- -- THINKME isn't this possible to do a bit nicer?
- let behaviour' = concatMap (\x -> if x=='\\' then "\\\\" else [x]) behaviour
- renameFile input_fn wrapped_executable
- let rtsDetails = (getPackageDetails (pkgState dflags) rtsPackageId);
- (md_c_flags, _) = machdepCCOpts dflags
- SysTools.runCc dflags
- ([ SysTools.FileOption "" ((head (libraryDirs rtsDetails)) ++ "/dyn-wrapper.c")
- , SysTools.Option ("-DBEHAVIOUR=\"" ++ behaviour' ++ "\"")
- , SysTools.Option "-o"
- , SysTools.FileOption "" input_fn] ++
- map (SysTools.FileOption "-I") (includeDirs rtsDetails) ++
- map Option md_c_flags)
- return True
- _ -> return True
| otherwise = return True
-wrapper_behaviour :: DynFlags -> Maybe [Char] -> [PackageId] -> IO [Char]
-wrapper_behaviour dflags mode dep_packages =
- let seperateBySemiColon strs = tail $ concatMap (';':) strs
- in case mode of
- Nothing -> do
- pkg_lib_paths <- getPackageLibraryPath dflags dep_packages
- return ('H' : (seperateBySemiColon pkg_lib_paths))
- Just s -> do
- allpkg <- getPreloadPackagesAnd dflags dep_packages
- putStrLn (unwords (map (packageIdString . packageConfigId) allpkg))
- return $ 'F':s ++ ';':(seperateBySemiColon (map (packageIdString . packageConfigId) allpkg))
-
mkExtraCObj :: DynFlags -> [String] -> IO FilePath
mkExtraCObj dflags xs
= do cFile <- newTempName dflags "c"
let
thread_opts | WayThreaded `elem` ways = [
-#if !defined(mingw32_TARGET_OS) && !defined(freebsd_TARGET_OS) && !defined(haiku_TARGET_OS)
+#if !defined(mingw32_TARGET_OS) && !defined(freebsd_TARGET_OS) && !defined(openbsd_TARGET_OS) && !defined(haiku_TARGET_OS)
"-lpthread"
#endif
#if defined(osf3_TARGET_OS)
))
-- parallel only: move binary to another dir -- HWL
- success <- runPhase_MoveBinary dflags output_fn dep_packages
+ success <- runPhase_MoveBinary dflags output_fn
if success then return ()
else ghcError (InstallationError ("cannot move binary"))
, SysTools.FileOption "" output_fn
])
-cHaskell1Version :: String
-cHaskell1Version = "5" -- i.e., Haskell 98
-
hsSourceCppOpts :: [String]
-- Default CPP defines in Haskell source
hsSourceCppOpts =
- [ "-D__HASKELL1__="++cHaskell1Version
- , "-D__GLASGOW_HASKELL__="++cProjectVersionInt
- , "-D__HASKELL98__"
- , "-D__CONCURRENT_HASKELL__"
- ]
+ [ "-D__GLASGOW_HASKELL__="++cProjectVersionInt ]
-- -----------------------------------------------------------------------------