X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Fmain%2FDriverPhases.hs;h=a16ad32c7b63c6d305828ec3dc67c9ac817a4934;hb=153b9cb9b11e05c4edb1b6bc0a7b972660e41f70;hp=cfe1b3e866a5cbd7068bba069b8952cd46b8fa9e;hpb=114470474d2e037d16b736354070fa03181e8348;p=ghc-hetmet.git diff --git a/ghc/compiler/main/DriverPhases.hs b/ghc/compiler/main/DriverPhases.hs index cfe1b3e..a16ad32 100644 --- a/ghc/compiler/main/DriverPhases.hs +++ b/ghc/compiler/main/DriverPhases.hs @@ -1,26 +1,31 @@ ----------------------------------------------------------------------------- --- $Id: DriverPhases.hs,v 1.13 2001/10/26 00:53:27 sof Exp $ +-- $Id: DriverPhases.hs,v 1.33 2005/01/28 12:55:33 simonmar Exp $ -- -- GHC Driver -- --- (c) Simon Marlow 2000 +-- (c) The University of Glasgow 2002 -- ----------------------------------------------------------------------------- -#include "../includes/config.h" - module DriverPhases ( - Phase(..), + HscSource(..), isHsBoot, hscSourceString, + HscTarget(..), Phase(..), + happensBefore, eqPhase, anyHsc, isStopPhase, startPhase, -- :: String -> Phase phaseInputExt, -- :: Phase -> String - haskellish_file, haskellish_suffix, - haskellish_src_file, haskellish_src_suffix, - objish_file, objish_suffix, - cish_file, cish_suffix + isHaskellishFilename, + isHaskellSrcFilename, + isObjectFilename, + isCishFilename, + isExtCoreFilename, + isDynLibFilename, + isHaskellUserSrcFilename, + isSourceFilename -- :: FilePath -> Bool ) where import DriverUtil +import Panic ( panic ) ----------------------------------------------------------------------------- -- Phases @@ -37,69 +42,183 @@ import DriverUtil linker | other | - | a.out -} +data HscSource + = HsSrcFile | HsBootFile | ExtCoreFile + deriving( Eq, Ord, Show ) + -- Ord needed for the finite maps we build in CompManager + + +hscSourceString :: HscSource -> String +hscSourceString HsSrcFile = "" +hscSourceString HsBootFile = "[boot]" +hscSourceString ExtCoreFile = "[ext core]" + +isHsBoot :: HscSource -> Bool +isHsBoot HsBootFile = True +isHsBoot other = False + +data HscTarget + = HscC + | HscAsm + | HscJava + | HscILX + | HscInterpreted + | HscNothing + deriving (Eq, Show) + data Phase - = MkDependHS -- haskell dependency generation - | Unlit - | Cpp - | HsPp - | Hsc -- ToDo: HscTargetLang + = Unlit HscSource + | Cpp HscSource + | HsPp HscSource + | Hsc HscSource | Cc | HCc -- Haskellised C (as opposed to vanilla C) compilation | Mangle -- assembly mangling, now done by a separate script. | SplitMangle -- after mangler if splitting | SplitAs | As - | Ln + | CmmCpp -- pre-process Cmm source + | Cmm -- parse & compile Cmm code #ifdef ILX | Ilx2Il | Ilasm #endif - deriving (Eq, Show) + + -- The final phase is a pseudo-phase that tells the pipeline to stop. + -- There is no runPhase case for it. + | StopLn -- Stop, but linking will follow, so generate .o file + + deriving (Show) + +anyHsc :: Phase +anyHsc = Hsc (panic "anyHsc") + +isStopPhase :: Phase -> Bool +isStopPhase StopLn = True +isStopPhase other = False + +eqPhase :: Phase -> Phase -> Bool +-- Equality of constructors, ignoring the HscSource field +eqPhase (Unlit _) (Unlit _) = True +eqPhase (Cpp _) (Cpp _) = True +eqPhase (HsPp _) (HsPp _) = True +eqPhase (Hsc _) (Hsc _) = True +eqPhase Cc Cc = True +eqPhase HCc HCc = True +eqPhase Mangle Mangle = True +eqPhase SplitMangle SplitMangle = True +eqPhase SplitAs SplitAs = True +eqPhase As As = True +eqPhase CmmCpp CmmCpp = True +eqPhase Cmm Cmm = True +eqPhase StopLn StopLn = True +eqPhase _ _ = False + +-- Partial ordering on phases: we want to know which phases will occur before +-- which others. This is used for sanity checking, to ensure that the +-- pipeline will stop at some point (see DriverPipeline.runPipeline). +StopLn `happensBefore` y = False +x `happensBefore` y = after_x `eqPhase` y || after_x `happensBefore` y + where + after_x = nextPhase x + +nextPhase :: Phase -> Phase +-- A conservative approximation the next phase, used in happensBefore +nextPhase (Unlit sf) = Cpp sf +nextPhase (Cpp sf) = HsPp sf +nextPhase (HsPp sf) = Hsc sf +nextPhase (Hsc sf) = HCc +nextPhase HCc = Mangle +nextPhase Mangle = SplitMangle +nextPhase SplitMangle = As +nextPhase As = SplitAs +nextPhase SplitAs = StopLn +nextPhase Cc = As +nextPhase CmmCpp = Cmm +nextPhase Cmm = HCc +nextPhase StopLn = panic "nextPhase: nothing after StopLn" -- the first compilation phase for a given file is determined -- by its suffix. -startPhase "lhs" = Unlit -startPhase "hs" = Cpp -startPhase "hscpp" = HsPp -startPhase "hspp" = Hsc -startPhase "hc" = HCc -startPhase "c" = Cc -startPhase "raw_s" = Mangle -startPhase "s" = As -startPhase "S" = As -startPhase "o" = Ln -startPhase _ = Ln -- all unknown file types - --- the output suffix for a given phase is uniquely determined by --- the input requirements of the next phase. -phaseInputExt Unlit = "lhs" -phaseInputExt Cpp = "lpp" -- intermediate only -phaseInputExt HsPp = "hscpp" -phaseInputExt Hsc = "hspp" -phaseInputExt HCc = "hc" -phaseInputExt Cc = "c" -phaseInputExt Mangle = "raw_s" -phaseInputExt SplitMangle = "split_s" -- not really generated -phaseInputExt As = "s" -phaseInputExt SplitAs = "split_s" -- not really generated -phaseInputExt Ln = "o" -phaseInputExt MkDependHS = "dep" +startPhase "lhs" = Unlit HsSrcFile +startPhase "lhs-boot" = Unlit HsBootFile +startPhase "hs" = Cpp HsSrcFile +startPhase "hs-boot" = Cpp HsBootFile +startPhase "hscpp" = HsPp HsSrcFile +startPhase "hspp" = Hsc HsSrcFile +startPhase "hcr" = Hsc ExtCoreFile +startPhase "hc" = HCc +startPhase "c" = Cc +startPhase "cpp" = Cc +startPhase "C" = Cc +startPhase "cc" = Cc +startPhase "cxx" = Cc +startPhase "raw_s" = Mangle +startPhase "s" = As +startPhase "S" = As +startPhase "o" = StopLn +startPhase "cmm" = CmmCpp +startPhase "cmmcpp" = Cmm +startPhase _ = StopLn -- all unknown file types + +-- This is used to determine the extension for the output from the +-- current phase (if it generates a new file). The extension depends +-- on the next phase in the pipeline. +phaseInputExt (Unlit HsSrcFile) = "lhs" +phaseInputExt (Unlit HsBootFile) = "lhs-boot" +phaseInputExt (Unlit ExtCoreFile) = "lhcr" +phaseInputExt (Cpp _) = "lpp" -- intermediate only +phaseInputExt (HsPp _) = "hscpp" -- intermediate only +phaseInputExt (Hsc _) = "hspp" -- intermediate only + -- NB: as things stand, phaseInputExt (Hsc x) must not evaluate x + -- because runPipeline uses the StopBefore phase to pick the + -- output filename. That could be fixed, but watch out. +phaseInputExt HCc = "hc" +phaseInputExt Cc = "c" +phaseInputExt Mangle = "raw_s" +phaseInputExt SplitMangle = "split_s" -- not really generated +phaseInputExt As = "s" +phaseInputExt SplitAs = "split_s" -- not really generated +phaseInputExt CmmCpp = "cmm" +phaseInputExt Cmm = "cmmcpp" +phaseInputExt StopLn = "o" #ifdef ILX -phaseInputExt Ilx2Il = "ilx" -phaseInputExt Ilasm = "il" +phaseInputExt Ilx2Il = "ilx" +phaseInputExt Ilasm = "il" #endif -haskellish_suffix = (`elem` [ "hs", "hspp", "hscpp", "lhs", "hc", "raw_s" ]) -haskellish_src_suffix = (`elem` [ "hs", "hspp", "hscpp", "lhs" ]) -cish_suffix = (`elem` [ "c", "s", "S" ]) -- maybe .cc et al.?? +haskellish_src_suffixes = haskellish_user_src_suffixes ++ + [ "hspp", "hscpp", "hcr", "cmm" ] +haskellish_suffixes = haskellish_src_suffixes ++ ["hc", "raw_s"] +cish_suffixes = [ "c", "cpp", "C", "cc", "cxx", "s", "S" ] +extcoreish_suffixes = [ "hcr" ] +haskellish_user_src_suffixes = [ "hs", "lhs", "hs-boot", "lhs-boot" ] -- Will not be deleted as temp files +-- Use the appropriate suffix for the system on which +-- the GHC-compiled code will run #if mingw32_TARGET_OS || cygwin32_TARGET_OS -objish_suffix = (`elem` [ "o", "O", "obj", "OBJ" ]) +objish_suffixes = [ "o", "O", "obj", "OBJ" ] #else -objish_suffix = (`elem` [ "o" ]) +objish_suffixes = [ "o" ] #endif -haskellish_file = haskellish_suffix . getFileSuffix -haskellish_src_file = haskellish_src_suffix . getFileSuffix -cish_file = cish_suffix . getFileSuffix -objish_file = objish_suffix . getFileSuffix +#ifdef mingw32_TARGET_OS +dynlib_suffixes = ["dll", "DLL"] +#elif defined(darwin_TARGET_OS) +dynlib_suffixes = ["dylib"] +#else +dynlib_suffixes = ["so"] +#endif + +isHaskellishFilename f = getFileSuffix f `elem` haskellish_suffixes +isHaskellSrcFilename f = getFileSuffix f `elem` haskellish_src_suffixes +isCishFilename f = getFileSuffix f `elem` cish_suffixes +isExtCoreFilename f = getFileSuffix f `elem` extcoreish_suffixes +isObjectFilename f = getFileSuffix f `elem` objish_suffixes +isHaskellUserSrcFilename f = getFileSuffix f `elem` haskellish_user_src_suffixes +isDynLibFilename f = getFileSuffix f `elem` dynlib_suffixes + +isSourceFilename :: FilePath -> Bool +isSourceFilename f = + isHaskellishFilename f || + isCishFilename f