import HscTypes
import Outputable
import Module
-import UniqFM ( eltsUFM )
+import LazyUniqFM ( eltsUFM )
import ErrUtils
import DynFlags
-import StaticFlags ( v_Ld_inputs, opt_Static, opt_HardwireLibPaths, WayName(..) )
+import StaticFlags ( v_Ld_inputs, opt_Static, WayName(..) )
import Config
import Panic
import Util
import Data.IORef ( readIORef, writeIORef, IORef )
import GHC.Exts ( Int(..) )
import System.Directory
+import System.FilePath
import System.IO
import SYSTEM_IO_ERROR as IO
import Control.Monad
debugTraceMsg dflags0 2 (text "compile: input file" <+> text input_fnpp)
- let (basename, _) = splitFilename input_fn
+ let basename = dropExtension input_fn
-- We add the directory in which the .hs files resides) to the import path.
-- This is needed when we try to compile the .hc file later, if it
-- imports a _stub.h file that we created here.
- let current_dir = directoryOf basename
+ let current_dir = case takeDirectory basename of
+ "" -> "." -- XXX Hack
+ d -> d
old_paths = includePaths dflags0
dflags = dflags0 { includePaths = current_dir : old_paths }
compileStub :: DynFlags -> Module -> ModLocation -> IO FilePath
compileStub dflags mod location = do
- let (o_base, o_ext) = splitFilename (ml_obj_file location)
- stub_o = o_base ++ "_stub" `joinFileExt` o_ext
+ let (o_base, o_ext) = splitExtension (ml_obj_file location)
+ stub_o = (o_base ++ "_stub") <.> o_ext
-- compile the _stub.c file w/ gcc
let (stub_c,_,_) = mkStubPaths dflags (moduleName mod) location
runPipeline stop_phase dflags0 (input_fn, mb_phase) mb_basename output maybe_loc
= do
let
- (input_basename, suffix) = splitFilename input_fn
+ (input_basename, suffix) = splitExtension input_fn
+ suffix' = drop 1 suffix -- strip off the .
basename | Just b <- mb_basename = b
| otherwise = input_basename
dflags = dflags0 { dumpPrefix = Just (basename ++ ".") }
-- If we were given a -x flag, then use that phase to start from
- start_phase = fromMaybe (startPhase suffix) mb_phase
+ start_phase = fromMaybe (startPhase suffix') mb_phase
-- We want to catch cases of "you can't get there from here" before
-- we start the pipeline, because otherwise it will just run off the
-- Execute the pipeline...
(dflags', output_fn, maybe_loc) <-
pipeLoop dflags start_phase stop_phase input_fn
- basename suffix get_output_fn maybe_loc
+ basename suffix' get_output_fn maybe_loc
-- Sometimes, a compilation phase doesn't actually generate any output
-- (eg. the CPP phase when -fcpp is not turned on). If we end on this
| StopLn <- next_phase = return odir_persistent
| otherwise = return persistent
- persistent = basename `joinFileExt` suffix
+ persistent = basename <.> suffix
odir_persistent
| Just loc <- maybe_location = ml_obj_file loc
- | Just d <- odir = d `joinFileName` persistent
+ | Just d <- odir = d </> persistent
| otherwise = persistent
-- Unlit phase
runPhase (Unlit sf) _stop dflags _basename _suff input_fn get_output_fn maybe_loc
- = do let unlit_flags = getOpts dflags opt_L
- -- The -h option passes the file name for unlit to put in a #line directive
+ = do
output_fn <- get_output_fn dflags (Cpp sf) maybe_loc
- SysTools.runUnlit dflags
- (map SysTools.Option unlit_flags ++
- [ SysTools.Option "-h"
- , SysTools.Option input_fn
- , SysTools.FileOption "" input_fn
- , SysTools.FileOption "" output_fn
- ])
+ let unlit_flags = getOpts dflags opt_L
+ flags = map SysTools.Option unlit_flags ++
+ [ -- The -h option passes the file name for unlit to
+ -- put in a #line directive
+ SysTools.Option "-h"
+ -- cpp interprets \b etc as escape sequences,
+ -- so we use / for filenames in pragmas
+ , SysTools.Option $ reslash Forwards $ normalise input_fn
+ , SysTools.FileOption "" input_fn
+ , SysTools.FileOption "" output_fn
+ ]
+
+ SysTools.runUnlit dflags flags
return (Cpp sf, dflags, maybe_loc, output_fn)
runPhase (Cpp sf) _stop dflags0 basename suff input_fn get_output_fn maybe_loc
= do src_opts <- getOptionsFromFile input_fn
(dflags,unhandled_flags) <- parseDynamicFlags dflags0 (map unLoc src_opts)
- checkProcessArgsResult unhandled_flags (basename `joinFileExt` suff)
+ checkProcessArgsResult unhandled_flags (basename <.> suff)
if not (dopt Opt_Cpp dflags) then
-- no need to preprocess CPP, just pass input file along
return (Hsc sf, dflags, maybe_loc, input_fn)
else do
let hspp_opts = getOpts dflags opt_F
- let orig_fn = basename `joinFileExt` suff
+ let orig_fn = basename <.> suff
output_fn <- get_output_fn dflags (Hsc sf) maybe_loc
SysTools.runPp dflags
( [ SysTools.Option orig_fn
-- we add the current directory (i.e. the directory in which
-- the .hs files resides) to the include path, since this is
-- what gcc does, and it's probably what you want.
- let current_dir = directoryOf basename
+ let current_dir = case takeDirectory basename of
+ "" -> "." -- XXX Hack
+ d -> d
paths = includePaths dflags0
dflags = dflags0 { includePaths = current_dir : paths }
; return (Nothing, mkModuleName m, [], []) }
_ -> do { buf <- hGetStringBuffer input_fn
- ; (src_imps,imps,L _ mod_name) <- getImports dflags buf input_fn (basename `joinFileExt` suff)
+ ; (src_imps,imps,L _ mod_name) <- getImports dflags buf input_fn (basename <.> suff)
; return (Just buf, mod_name, imps, src_imps) }
-- Build a ModLocation to pass to hscMain.
-- changed (which the compiler itself figures out).
-- Setting source_unchanged to False tells the compiler that M.o is out of
-- date wrt M.hs (or M.o doesn't exist) so we must recompile regardless.
- src_timestamp <- getModificationTime (basename `joinFileExt` suff)
+ src_timestamp <- getModificationTime (basename <.> suff)
let force_recomp = dopt Opt_ForceRecomp dflags
source_unchanged <-
pkg_extra_cc_opts <- getPackageExtraCcOpts dflags pkgs
+#ifdef darwin_TARGET_OS
+ pkg_framework_paths <- getPackageFrameworkPath dflags pkgs
+ let cmdline_framework_paths = frameworkPaths dflags
+ let framework_paths = map ("-F"++)
+ (cmdline_framework_paths ++ pkg_framework_paths)
+#endif
+
let split_objs = dopt Opt_SplitObjs dflags
split_opt | hcc && split_objs = [ "-DUSE_SPLIT_MARKERS" ]
| otherwise = [ ]
else [])
++ [ verb, "-S", "-Wimplicit", cc_opt ]
++ [ "-D__GLASGOW_HASKELL__="++cProjectVersionInt ]
+#ifdef darwin_TARGET_OS
+ ++ framework_paths
+#endif
++ cc_opts
++ split_opt
++ include_paths
-- we create directories for the object file, because it
-- might be a hierarchical module.
- createDirectoryHierarchy (directoryOf output_fn)
+ createDirectoryHierarchy (takeDirectory output_fn)
SysTools.runAs dflags
(map SysTools.Option as_opts
runPhase SplitAs _stop dflags _basename _suff _input_fn get_output_fn maybe_loc
- = do
- output_fn <- get_output_fn dflags StopLn maybe_loc
-
- let (base_o, _) = splitFilename output_fn
- split_odir = base_o ++ "_split"
- osuf = objectSuf dflags
-
- createDirectoryHierarchy split_odir
-
- -- remove M_split/ *.o, because we're going to archive M_split/ *.o
- -- later and we don't want to pick up any old objects.
- fs <- getDirectoryContents split_odir
- mapM_ removeFile $ map (split_odir `joinFileName`)
- $ filter (osuf `isSuffixOf`) fs
-
- let as_opts = getOpts dflags opt_a
-
- (split_s_prefix, n) <- readIORef v_Split_info
-
- let split_s n = split_s_prefix ++ "__" ++ show n `joinFileExt` "s"
- split_obj n = split_odir `joinFileName`
- filenameOf base_o ++ "__" ++ show n
- `joinFileExt` osuf
-
- let assemble_file n
- = SysTools.runAs dflags
- (map SysTools.Option as_opts ++
- [ SysTools.Option "-c"
- , SysTools.Option "-o"
- , SysTools.FileOption "" (split_obj n)
- , SysTools.FileOption "" (split_s n)
- ])
-
- mapM_ assemble_file [1..n]
-
- -- and join the split objects into a single object file:
- let ld_r args = SysTools.runLink dflags ([
- SysTools.Option "-nostdlib",
- SysTools.Option "-nodefaultlibs",
- SysTools.Option "-Wl,-r",
- SysTools.Option ld_x_flag,
- SysTools.Option "-o",
- SysTools.FileOption "" output_fn ] ++ args)
+ = do
+ output_fn <- get_output_fn dflags StopLn maybe_loc
+
+ let base_o = dropExtension output_fn
+ split_odir = base_o ++ "_split"
+ osuf = objectSuf dflags
+
+ createDirectoryHierarchy split_odir
+
+ -- remove M_split/ *.o, because we're going to archive M_split/ *.o
+ -- later and we don't want to pick up any old objects.
+ fs <- getDirectoryContents split_odir
+ mapM_ removeFile $ map (split_odir </>) $ filter (osuf `isSuffixOf`) fs
+
+ let as_opts = getOpts dflags opt_a
+
+ (split_s_prefix, n) <- readIORef v_Split_info
+
+ let split_s n = split_s_prefix ++ "__" ++ show n <.> "s"
+ split_obj n = split_odir </>
+ takeFileName base_o ++ "__" ++ show n <.> osuf
+
+ let assemble_file n
+ = SysTools.runAs dflags
+ (map SysTools.Option as_opts ++
+ [ SysTools.Option "-c"
+ , SysTools.Option "-o"
+ , SysTools.FileOption "" (split_obj n)
+ , SysTools.FileOption "" (split_s n)
+ ])
+
+ mapM_ assemble_file [1..n]
+
+ -- and join the split objects into a single object file:
+ let ld_r args = SysTools.runLink dflags ([
+ SysTools.Option "-nostdlib",
+ SysTools.Option "-nodefaultlibs",
+ SysTools.Option "-Wl,-r",
+ SysTools.Option ld_x_flag,
+ SysTools.Option "-o",
+ SysTools.FileOption "" output_fn ] ++ args)
ld_x_flag | null cLD_X = ""
- | otherwise = "-Wl,-x"
+ | otherwise = "-Wl,-x"
- if cLdIsGNULd == "YES"
- then do
- let script = split_odir `joinFileName` "ld.script"
- writeFile script $
- "INPUT(" ++ unwords (map split_obj [1..n]) ++ ")"
- ld_r [SysTools.FileOption "" script]
- else do
- ld_r (map (SysTools.FileOption "" . split_obj) [1..n])
+ if cLdIsGNULd == "YES"
+ then do
+ let script = split_odir </> "ld.script"
+ writeFile script $
+ "INPUT(" ++ unwords (map split_obj [1..n]) ++ ")"
+ ld_r [SysTools.FileOption "" script]
+ else do
+ ld_r (map (SysTools.FileOption "" . split_obj) [1..n])
- return (StopLn, dflags, maybe_loc, output_fn)
+ return (StopLn, dflags, maybe_loc, output_fn)
-- warning suppression
runPhase other _stop _dflags _basename _suff _input_fn _get_output_fn _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 -> IO Bool
-runPhase_MoveBinary dflags input_fn
- = do
+runPhase_MoveBinary :: DynFlags -> FilePath -> [PackageId] -> IO Bool
+runPhase_MoveBinary dflags input_fn dep_packages
+ | WayPar `elem` (wayNames dflags) && not opt_Static =
+ panic ("Don't know how to combine PVM wrapper and dynamic wrapper")
+ | WayPar `elem` (wayNames dflags) = do
let sysMan = pgm_sysman dflags
pvm_root <- getEnv "PVM_ROOT"
pvm_arch <- getEnv "PVM_ARCH"
- let
+ let
pvm_executable_base = "=" ++ input_fn
pvm_executable = pvm_root ++ "/bin/" ++ pvm_arch ++ "/" ++ pvm_executable_base
-- nuke old binary; maybe use configur'ed names for cp and rm?
-- 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 ++ "_real") <.> o_ext
+ | otherwise = input_fn ++ "_real"
+ 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);
+ 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))
+ 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))
-- generates a Perl skript starting a parallel prg under PVM
mk_pvm_wrapper_script :: String -> String -> String -> String
pkg_lib_paths <- getPackageLibraryPath dflags dep_packages
let pkg_lib_path_opts = concat (map get_pkg_lib_path_opts pkg_lib_paths)
- get_pkg_lib_path_opts l | opt_HardwireLibPaths && not opt_Static = ["-L" ++ l, "-Wl,-rpath", "-Wl," ++ l]
- | otherwise = ["-L" ++ l]
+#ifdef linux_TARGET_OS
+ get_pkg_lib_path_opts l | (dynLibLoader dflags)==SystemDependent && not opt_Static = ["-L" ++ l, "-Wl,-rpath", "-Wl," ++ l]
+ | otherwise = ["-L" ++ l]
+#else
+ get_pkg_lib_path_opts l = ["-L" ++ l]
+#endif
let lib_paths = libraryPaths dflags
let lib_path_opts = map ("-L"++) lib_paths
framework_opts = concat [ ["-framework", fw] | fw <- reverse frameworks ]
-- reverse because they're added in reverse order from the cmd line
#endif
-
+#ifdef mingw32_TARGET_OS
+ let dynMain = if not opt_Static then
+ (head (libraryDirs (getPackageDetails (pkgState dflags) rtsPackageId))) ++ "/Main.dyn_o"
+ else
+ ""
+#endif
-- probably _stub.o files
extra_ld_inputs <- readIORef v_Ld_inputs
++ map SysTools.Option (
md_c_flags
++ o_files
+#ifdef mingw32_TARGET_OS
+ ++ [dynMain]
+#endif
++ extra_ld_inputs
++ lib_path_opts
++ extra_ld_opts
))
-- parallel only: move binary to another dir -- HWL
- when (WayPar `elem` ways)
- (do success <- runPhase_MoveBinary dflags output_fn
- if success then return ()
- else throwDyn (InstallationError ("cannot move binary to PVM dir")))
+ success <- runPhase_MoveBinary dflags output_fn dep_packages
+ if success then return ()
+ else throwDyn (InstallationError ("cannot move binary"))
exeFileName :: DynFlags -> FilePath
exeFileName dflags
- | Just s <- outputFile dflags =
+ | Just s <- outputFile dflags =
#if defined(mingw32_HOST_OS)
- if null (suffixOf s)
- then s `joinFileExt` "exe"
+ if null (takeExtension s)
+ then s <.> "exe"
else s
#else
s
maybeCreateManifest dflags exe_filename = do
if not (dopt Opt_GenManifest dflags) then return [] else do
- let manifest_filename = exe_filename `joinFileExt` "manifest"
+ let manifest_filename = exe_filename <.> "manifest"
writeFile manifest_filename $
"<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n"++
" <assembly xmlns=\"urn:schemas-microsoft-com:asm.v1\" manifestVersion=\"1.0\">\n"++
" <assemblyIdentity version=\"1.0.0.0\"\n"++
" processorArchitecture=\"X86\"\n"++
- " name=\"" ++ basenameOf exe_filename ++ "\"\n"++
+ " name=\"" ++ dropExtension exe_filename ++ "\"\n"++
" type=\"win32\"/>\n\n"++
" <trustInfo xmlns=\"urn:schemas-microsoft-com:asm.v3\">\n"++
" <security>\n"++
++ map SysTools.Option (
md_c_flags
++ o_files
- ++ [ "-undefined", "dynamic_lookup", "-single_module", "-Wl,-macosx_version_min","-Wl,10.3", "-install_name " ++ (pwd `joinFileName` output_fn) ]
+ ++ [ "-undefined", "dynamic_lookup", "-single_module", "-Wl,-macosx_version_min","-Wl,10.3", "-install_name " ++ (pwd </> output_fn) ]
++ extra_ld_inputs
++ lib_path_opts
++ extra_ld_opts
projects / ghc-hetmet.git / blobdiff