compiler/main/DriverPhases.hs

   1 -----------------------------------------------------------------------------
   2 --  $Id: DriverPhases.hs,v 1.38 2005/05/17 11:01:59 simonmar Exp $
   3 --
   4 -- GHC Driver
   5 --
   6 -- (c) The University of Glasgow 2002
   7 --
   8 -----------------------------------------------------------------------------
   9
  10 module DriverPhases (
  11    HscSource(..), isHsBoot, hscSourceString,
  12    Phase(..),
  13    happensBefore, eqPhase, anyHsc, isStopLn,
  14    startPhase,          -- :: String -> Phase
  15    phaseInputExt,       -- :: Phase -> String
  16
  17    isHaskellishSuffix,
  18    isHaskellSrcSuffix,
  19    isObjectSuffix,
  20    isCishSuffix,
  21    isExtCoreSuffix,
  22    isDynLibSuffix,
  23    isHaskellUserSrcSuffix,
  24    isSourceSuffix,
  25
  26    isHaskellishFilename,
  27    isHaskellSrcFilename,
  28    isObjectFilename,
  29    isCishFilename,
  30    isExtCoreFilename,
  31    isDynLibFilename,
  32    isHaskellUserSrcFilename,
  33    isSourceFilename         -- :: FilePath -> Bool
  34  ) where
  35
  36 #include "HsVersions.h"
  37
  38 import Panic            ( panic )
  39 import System.FilePath
  40
  41 -----------------------------------------------------------------------------
  42 -- Phases
  43
  44 {-
  45    Phase of the           | Suffix saying | Flag saying   | (suffix of)
  46    compilation system     | ``start here''| ``stop after''| output file
  47
  48    literate pre-processor | .lhs          | -             | -
  49    C pre-processor (opt.) | -             | -E            | -
  50    Haskell compiler       | .hs           | -C, -S        | .hc, .s
  51    C compiler (opt.)      | .hc or .c     | -S            | .s
  52    assembler              | .s  or .S     | -c            | .o
  53    linker                 | other         | -             | a.out
  54 -}
  55
  56 data HscSource
  57    = HsSrcFile | HsBootFile | ExtCoreFile
  58      deriving( Eq, Ord, Show )
  59         -- Ord needed for the finite maps we build in CompManager
  60
  61
  62 hscSourceString :: HscSource -> String
  63 hscSourceString HsSrcFile   = ""
  64 hscSourceString HsBootFile  = "[boot]"
  65 hscSourceString ExtCoreFile = "[ext core]"
  66
  67 isHsBoot :: HscSource -> Bool
  68 isHsBoot HsBootFile = True
  69 isHsBoot _          = False
  70
  71 data Phase
  72         = Unlit HscSource
  73         | Cpp   HscSource
  74         | HsPp  HscSource
  75         | Hsc   HscSource
  76         | Ccpp
  77         | Cc
  78         | HCc           -- Haskellised C (as opposed to vanilla C) compilation
  79         | Mangle        -- assembly mangling, now done by a separate script.
  80         | SplitMangle   -- after mangler if splitting
  81         | SplitAs
  82         | As
  83         | LlvmOpt       -- Run LLVM opt tool over llvm assembly
  84         | LlvmLlc       -- LLVM bitcode to native assembly
  85         | LlvmMangle    -- Fix up TNTC by processing assembly produced by LLVM
  86         | CmmCpp        -- pre-process Cmm source
  87         | Cmm           -- parse & compile Cmm code
  88
  89         -- The final phase is a pseudo-phase that tells the pipeline to stop.
  90         -- There is no runPhase case for it.
  91         | StopLn        -- Stop, but linking will follow, so generate .o file
  92   deriving (Eq, Show)
  93
  94 anyHsc :: Phase
  95 anyHsc = Hsc (panic "anyHsc")
  96
  97 isStopLn :: Phase -> Bool
  98 isStopLn StopLn = True
  99 isStopLn _      = False
 100
 101 eqPhase :: Phase -> Phase -> Bool
 102 -- Equality of constructors, ignoring the HscSource field
 103 -- NB: the HscSource field can be 'bot'; see anyHsc above
 104 eqPhase (Unlit _)   (Unlit _)   = True
 105 eqPhase (Cpp   _)   (Cpp   _)   = True
 106 eqPhase (HsPp  _)   (HsPp  _)   = True
 107 eqPhase (Hsc   _)   (Hsc   _)   = True
 108 eqPhase Ccpp        Ccpp        = True
 109 eqPhase Cc          Cc          = True
 110 eqPhase HCc         HCc         = True
 111 eqPhase Mangle      Mangle      = True
 112 eqPhase SplitMangle SplitMangle = True
 113 eqPhase SplitAs     SplitAs     = True
 114 eqPhase As          As          = True
 115 eqPhase LlvmOpt     LlvmOpt     = True
 116 eqPhase LlvmLlc     LlvmLlc     = True
 117 eqPhase LlvmMangle  LlvmMangle  = True
 118 eqPhase CmmCpp      CmmCpp      = True
 119 eqPhase Cmm         Cmm         = True
 120 eqPhase StopLn      StopLn      = True
 121 eqPhase _           _           = False
 122
 123 -- Partial ordering on phases: we want to know which phases will occur before
 124 -- which others.  This is used for sanity checking, to ensure that the
 125 -- pipeline will stop at some point (see DriverPipeline.runPipeline).
 126 happensBefore :: Phase -> Phase -> Bool
 127 StopLn `happensBefore` _ = False
 128 x      `happensBefore` y = after_x `eqPhase` y || after_x `happensBefore` y
 129         where
 130           after_x = nextPhase x
 131
 132 nextPhase :: Phase -> Phase
 133 -- A conservative approximation the next phase, used in happensBefore
 134 nextPhase (Unlit sf)    = Cpp  sf
 135 nextPhase (Cpp   sf)    = HsPp sf
 136 nextPhase (HsPp  sf)    = Hsc  sf
 137 nextPhase (Hsc   _)     = HCc
 138 nextPhase HCc           = Mangle
 139 nextPhase Mangle        = SplitMangle
 140 nextPhase SplitMangle   = As
 141 nextPhase As            = SplitAs
 142 nextPhase LlvmOpt       = LlvmLlc
 143 #if darwin_TARGET_OS
 144 nextPhase LlvmLlc       = LlvmMangle
 145 #else
 146 nextPhase LlvmLlc       = As
 147 #endif
 148 nextPhase LlvmMangle    = As
 149 nextPhase SplitAs       = StopLn
 150 nextPhase Ccpp          = As
 151 nextPhase Cc            = As
 152 nextPhase CmmCpp        = Cmm
 153 nextPhase Cmm           = HCc
 154 nextPhase StopLn        = panic "nextPhase: nothing after StopLn"
 155
 156 -- the first compilation phase for a given file is determined
 157 -- by its suffix.
 158 startPhase :: String -> Phase
 159 startPhase "lhs"      = Unlit HsSrcFile
 160 startPhase "lhs-boot" = Unlit HsBootFile
 161 startPhase "hs"       = Cpp   HsSrcFile
 162 startPhase "hs-boot"  = Cpp   HsBootFile
 163 startPhase "hscpp"    = HsPp  HsSrcFile
 164 startPhase "hspp"     = Hsc   HsSrcFile
 165 startPhase "hcr"      = Hsc   ExtCoreFile
 166 startPhase "hc"       = HCc
 167 startPhase "c"        = Cc
 168 startPhase "cpp"      = Ccpp
 169 startPhase "C"        = Cc
 170 startPhase "cc"       = Ccpp
 171 startPhase "cxx"      = Ccpp
 172 startPhase "raw_s"    = Mangle
 173 startPhase "split_s"  = SplitMangle
 174 startPhase "s"        = As
 175 startPhase "S"        = As
 176 startPhase "ll"       = LlvmOpt
 177 startPhase "bc"       = LlvmLlc
 178 startPhase "lm_s"     = LlvmMangle
 179 startPhase "o"        = StopLn
 180 startPhase "cmm"      = CmmCpp
 181 startPhase "cmmcpp"   = Cmm
 182 startPhase _          = StopLn     -- all unknown file types
 183
 184 -- This is used to determine the extension for the output from the
 185 -- current phase (if it generates a new file).  The extension depends
 186 -- on the next phase in the pipeline.
 187 phaseInputExt :: Phase -> String
 188 phaseInputExt (Unlit HsSrcFile)   = "lhs"
 189 phaseInputExt (Unlit HsBootFile)  = "lhs-boot"
 190 phaseInputExt (Unlit ExtCoreFile) = "lhcr"
 191 phaseInputExt (Cpp   _)           = "lpp"       -- intermediate only
 192 phaseInputExt (HsPp  _)           = "hscpp"     -- intermediate only
 193 phaseInputExt (Hsc   _)           = "hspp"      -- intermediate only
 194         -- NB: as things stand, phaseInputExt (Hsc x) must not evaluate x
 195         --     because runPipeline uses the StopBefore phase to pick the
 196         --     output filename.  That could be fixed, but watch out.
 197 phaseInputExt HCc                 = "hc"
 198 phaseInputExt Ccpp                = "cpp"
 199 phaseInputExt Cc                  = "c"
 200 phaseInputExt Mangle              = "raw_s"
 201 phaseInputExt SplitMangle         = "split_s"   -- not really generated
 202 phaseInputExt As                  = "s"
 203 phaseInputExt LlvmOpt             = "ll"
 204 phaseInputExt LlvmLlc             = "bc"
 205 phaseInputExt LlvmMangle          = "lm_s"
 206 phaseInputExt SplitAs             = "split_s"   -- not really generated
 207 phaseInputExt CmmCpp              = "cmm"
 208 phaseInputExt Cmm                 = "cmmcpp"
 209 phaseInputExt StopLn              = "o"
 210
 211 haskellish_src_suffixes, haskellish_suffixes, cish_suffixes,
 212     extcoreish_suffixes, haskellish_user_src_suffixes
 213  :: [String]
 214 haskellish_src_suffixes      = haskellish_user_src_suffixes ++
 215                                [ "hspp", "hscpp", "hcr", "cmm" ]
 216 haskellish_suffixes          = haskellish_src_suffixes ++ ["hc", "raw_s"]
 217 cish_suffixes                = [ "c", "cpp", "C", "cc", "cxx", "s", "S", "ll", "bc" ]
 218 extcoreish_suffixes          = [ "hcr" ]
 219 -- Will not be deleted as temp files:
 220 haskellish_user_src_suffixes = [ "hs", "lhs", "hs-boot", "lhs-boot" ]
 221
 222 objish_suffixes :: [String]
 223 -- Use the appropriate suffix for the system on which
 224 -- the GHC-compiled code will run
 225 #if mingw32_TARGET_OS || cygwin32_TARGET_OS
 226 objish_suffixes     = [ "o", "O", "obj", "OBJ" ]
 227 #else
 228 objish_suffixes     = [ "o" ]
 229 #endif
 230
 231 dynlib_suffixes :: [String]
 232 #ifdef mingw32_TARGET_OS
 233 dynlib_suffixes = ["dll", "DLL"]
 234 #elif defined(darwin_TARGET_OS)
 235 dynlib_suffixes = ["dylib"]
 236 #else
 237 dynlib_suffixes = ["so"]
 238 #endif
 239
 240 isHaskellishSuffix, isHaskellSrcSuffix, isCishSuffix, isExtCoreSuffix,
 241     isObjectSuffix, isHaskellUserSrcSuffix, isDynLibSuffix
 242  :: String -> Bool
 243 isHaskellishSuffix     s = s `elem` haskellish_suffixes
 244 isHaskellSrcSuffix     s = s `elem` haskellish_src_suffixes
 245 isCishSuffix           s = s `elem` cish_suffixes
 246 isExtCoreSuffix        s = s `elem` extcoreish_suffixes
 247 isObjectSuffix         s = s `elem` objish_suffixes
 248 isHaskellUserSrcSuffix s = s `elem` haskellish_user_src_suffixes
 249 isDynLibSuffix         s = s `elem` dynlib_suffixes
 250
 251 isSourceSuffix :: String -> Bool
 252 isSourceSuffix suff  = isHaskellishSuffix suff || isCishSuffix suff
 253
 254 isHaskellishFilename, isHaskellSrcFilename, isCishFilename,
 255     isExtCoreFilename, isObjectFilename, isHaskellUserSrcFilename,
 256     isDynLibFilename, isSourceFilename
 257  :: FilePath -> Bool
 258 -- takeExtension return .foo, so we drop 1 to get rid of the .
 259 isHaskellishFilename     f = isHaskellishSuffix     (drop 1 $ takeExtension f)
 260 isHaskellSrcFilename     f = isHaskellSrcSuffix     (drop 1 $ takeExtension f)
 261 isCishFilename           f = isCishSuffix           (drop 1 $ takeExtension f)
 262 isExtCoreFilename        f = isExtCoreSuffix        (drop 1 $ takeExtension f)
 263 isObjectFilename         f = isObjectSuffix         (drop 1 $ takeExtension f)
 264 isHaskellUserSrcFilename f = isHaskellUserSrcSuffix (drop 1 $ takeExtension f)
 265 isDynLibFilename         f = isDynLibSuffix         (drop 1 $ takeExtension f)
 266 isSourceFilename         f = isSourceSuffix         (drop 1 $ takeExtension f)
 267
 268