HscTypes.lhs 81.3 KB
Newer Older
1 2
%
% (c) The University of Glasgow, 2006
3 4 5 6
%
\section[HscTypes]{Types for the per-module compiler}

\begin{code}
7
-- | Types for the per-module compiler
8
module HscTypes ( 
9 10 11 12 13 14 15
        -- * 'Ghc' monad stuff
        Ghc(..), GhcT(..), liftGhcT,
        GhcMonad(..), WarnLogMonad(..),
        liftIO,
        ioMsgMaybe, ioMsg,
        logWarnings, clearWarnings, hasWarnings,
        SourceError, GhcApiError, mkSrcErr, srcErrorMessages, mkApiErr,
16
        throwOneError, handleSourceError,
17
        reflectGhc, reifyGhc,
18
        handleFlagWarnings,
19

20
	-- * Sessions and compilation state
Thomas Schilling's avatar
Thomas Schilling committed
21
	Session(..), withSession, modifySession, withTempSession,
22
        HscEnv(..), hscEPS,
Simon Marlow's avatar
Simon Marlow committed
23
	FinderCache, FindResult(..), ModLocationCache,
24 25
	Target(..), TargetId(..), pprTarget, pprTargetId,
	ModuleGraph, emptyMG,
26 27
        -- ** Callbacks
        GhcApiCallbacks(..), withLocalCallbacks,
28

29
        -- * Information about modules
30
	ModDetails(..),	emptyModDetails,
31
	ModGuts(..), CoreModule(..), CgGuts(..), ForeignStubs(..),
Simon Marlow's avatar
Simon Marlow committed
32
        ImportedMods,
33

34
	ModSummary(..), ms_mod_name, showModMsg, isBootSummary,
35
	msHsFilePath, msHiFilePath, msObjFilePath,
36

37
        -- * Information about the module being compiled
38 39
	HscSource(..), isHsBoot, hscSourceString,	-- Re-exported from DriverPhases
	
40
	-- * State relating to modules in this package
41
	HomePackageTable, HomeModInfo(..), emptyHomePackageTable,
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
42
	hptInstances, hptRules, hptVectInfo,
43 44
	
	-- * State relating to known packages
45
	ExternalPackageState(..), EpsStats(..), addEpsInStats,
46
	PackageTypeEnv, PackageIfaceTable, emptyPackageIfaceTable,
Simon Marlow's avatar
Simon Marlow committed
47
	lookupIfaceByModule, emptyModIface,
48 49
	
	PackageInstEnv, PackageRuleBase,
50

51 52 53 54

        -- * Annotations
        prepareAnnotations,

55
        -- * Interactive context
56
	InteractiveContext(..), emptyInteractiveContext, 
57
	icPrintUnqual, extendInteractiveContext,
mnislaih's avatar
mnislaih committed
58
        substInteractiveContext,
59
        mkPrintUnqualified, pprModulePrefix,
60

61
	-- * Interfaces
Ian Lynagh's avatar
Ian Lynagh committed
62 63
	ModIface(..), mkIfaceWarnCache, mkIfaceHashCache, mkIfaceFixCache,
	emptyIfaceWarnCache,
64

65
        -- * Fixity
66
	FixityEnv, FixItem(..), lookupFixity, emptyFixityEnv,
67

68 69 70
        -- * TyThings and type environments
	TyThing(..),
	tyThingClass, tyThingTyCon, tyThingDataCon, tyThingId,
71
	implicitTyThings, isImplicitTyThing,
72 73
	
	TypeEnv, lookupType, lookupTypeHscEnv, mkTypeEnv, emptyTypeEnv,
74
	extendTypeEnv, extendTypeEnvList, extendTypeEnvWithIds, lookupTypeEnv,
75
	typeEnvElts, typeEnvClasses, typeEnvTyCons, typeEnvIds,
76
	typeEnvDataCons,
77

78 79 80 81
        -- * MonadThings
        MonadThings(..),

        -- * Information on imports and exports
82
	WhetherHasOrphans, IsBootInterface, Usage(..), 
83
	Dependencies(..), noDependencies,
84
	NameCache(..), OrigNameCache, OrigIParamCache,
85
	Avails, availsToNameSet, availsToNameEnv, availName, availNames,
86
	GenAvailInfo(..), AvailInfo, RdrAvailInfo, 
87
	IfaceExport,
88

89
	-- * Warnings
Ian Lynagh's avatar
Ian Lynagh committed
90
	Warnings(..), WarningTxt(..), plusWarns,
91

92
	-- * Linker stuff
93 94
	Linkable(..), isObjectLinkable,
	Unlinked(..), CompiledByteCode,
andy@galois.com's avatar
andy@galois.com committed
95
	isObject, nameOfObject, isInterpretable, byteCodeOfObject,
96 97
        
        -- * Program coverage
98
        HpcInfo(..), emptyHpcInfo, isHpcUsed, AnyHpcUsage,
99

100
        -- * Breakpoints
101 102
        ModBreaks (..), BreakIndex, emptyModBreaks,

103
        -- * Vectorisation information
104 105
        VectInfo(..), IfaceVectInfo(..), noVectInfo, plusVectInfo, 
        noIfaceVectInfo
106
    ) where
107 108 109

#include "HsVersions.h"

110 111
#ifdef GHCI
import ByteCodeAsm	( CompiledByteCode )
112
import {-# SOURCE #-}  InteractiveEval ( Resume )
113 114
#endif

115
import HsSyn
116
import RdrName
117
import Name
118
import NameEnv
119
import NameSet	
120
import Module
121
import InstEnv		( InstEnv, Instance )
122
import FamInstEnv	( FamInstEnv, FamInst )
123
import Rules		( RuleBase )
124
import CoreSyn		( CoreBind )
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
125
import VarEnv
126
import VarSet
127
import Var
128
import Id
mnislaih's avatar
mnislaih committed
129
import Type		
130

131
import Annotations
132
import Class		( Class, classSelIds, classATs, classTyCon )
133
import TyCon
134
import DataCon		( DataCon, dataConImplicitIds, dataConWrapId )
135
import PrelNames	( gHC_PRIM )
136
import Packages hiding ( Version(..) )
137 138
import DynFlags		( DynFlags(..), isOneShot, HscTarget (..), dopt,
                          DynFlag(..) )
139
import DriverPhases	( HscSource(..), isHsBoot, hscSourceString, Phase )
Ian Lynagh's avatar
Ian Lynagh committed
140
import BasicTypes	( IPName, defaultFixity, WarningTxt(..) )
dias@eecs.harvard.edu's avatar
dias@eecs.harvard.edu committed
141
import OptimizationFuel	( OptFuelState )
142
import IfaceSyn
143
import FiniteMap	( FiniteMap )
144
import CoreSyn		( CoreRule )
145
import Maybes		( orElse, expectJust, catMaybes )
146
import Outputable
147
import BreakArray
148
import SrcLoc		( SrcSpan, Located(..) )
149
import LazyUniqFM		( lookupUFM, eltsUFM, emptyUFM )
150
import UniqSupply	( UniqSupply )
151
import FastString
152
import StringBuffer	( StringBuffer )
153
import Fingerprint
154 155 156
import MonadUtils
import Data.Dynamic     ( Typeable )
import qualified Data.Dynamic as Dyn
157 158
import Bag
import ErrUtils
Simon Marlow's avatar
Simon Marlow committed
159

160
import System.FilePath
Simon Marlow's avatar
Simon Marlow committed
161
import System.Time	( ClockTime )
162
import Data.IORef
163
import Data.Array       ( Array, array )
mnislaih's avatar
mnislaih committed
164
import Data.List
165
import Control.Monad    ( mplus, guard, liftM, when )
166
import Exception
167 168
\end{code}

169

170 171
%************************************************************************
%*									*
172
\subsection{Compilation environment}
173 174 175
%*									*
%************************************************************************

176 177 178 179 180 181

\begin{code}
-- | The Session is a handle to the complete state of a compilation
-- session.  A compilation session consists of a set of modules
-- constituting the current program or library, the context for
-- interactive evaluation, and various caches.
182 183 184 185 186 187
data Session = Session !(IORef HscEnv) !(IORef WarningMessages)

mkSrcErr :: ErrorMessages -> SourceError
srcErrorMessages :: SourceError -> ErrorMessages
mkApiErr :: SDoc -> GhcApiError

188 189 190
throwOneError :: MonadIO m => ErrMsg -> m ab
throwOneError err = liftIO $ throwIO $ mkSrcErr $ unitBag err

191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297
-- | A source error is an error that is caused by one or more errors in the
-- source code.  A 'SourceError' is thrown by many functions in the
-- compilation pipeline.  Inside GHC these errors are merely printed via
-- 'log_action', but API clients may treat them differently, for example,
-- insert them into a list box.  If you want the default behaviour, use the
-- idiom:
--
-- > handleSourceError printExceptionAndWarnings $ do
-- >   ... api calls that may fail ...
--
-- The 'SourceError's error messages can be accessed via 'srcErrorMessages'.
-- This list may be empty if the compiler failed due to @-Werror@
-- ('Opt_WarnIsError').
--
-- See 'printExceptionAndWarnings' for more information on what to take care
-- of when writing a custom error handler.
data SourceError = SourceError ErrorMessages

instance Show SourceError where
  show (SourceError msgs) = unlines . map show . bagToList $ msgs
    -- ToDo: is there some nicer way to print this?

sourceErrorTc :: Dyn.TyCon
sourceErrorTc = Dyn.mkTyCon "SourceError"
{-# NOINLINE sourceErrorTc #-}
instance Typeable SourceError where
  typeOf _ = Dyn.mkTyConApp sourceErrorTc []

instance Exception SourceError

mkSrcErr = SourceError

-- | Perform the given action and call the exception handler if the action
-- throws a 'SourceError'.  See 'SourceError' for more information.
handleSourceError :: (ExceptionMonad m) =>
                     (SourceError -> m a) -- ^ exception handler
                  -> m a -- ^ action to perform
                  -> m a
handleSourceError handler act =
  gcatch act (\(e :: SourceError) -> handler e)

srcErrorMessages (SourceError msgs) = msgs

-- | XXX: what exactly is an API error?
data GhcApiError = GhcApiError SDoc

instance Show GhcApiError where
  show (GhcApiError msg) = showSDoc msg

ghcApiErrorTc :: Dyn.TyCon
ghcApiErrorTc = Dyn.mkTyCon "GhcApiError"
{-# NOINLINE ghcApiErrorTc #-}
instance Typeable GhcApiError where
  typeOf _ = Dyn.mkTyConApp ghcApiErrorTc []

instance Exception GhcApiError

mkApiErr = GhcApiError

-- | A monad that allows logging of warnings.
class Monad m => WarnLogMonad m where
  setWarnings  :: WarningMessages -> m ()
  getWarnings :: m WarningMessages

logWarnings :: WarnLogMonad m => WarningMessages -> m ()
logWarnings warns = do
    warns0 <- getWarnings
    setWarnings (unionBags warns warns0)

-- | Clear the log of 'Warnings'.
clearWarnings :: WarnLogMonad m => m ()
clearWarnings = setWarnings emptyBag

-- | Returns true if there were any warnings.
hasWarnings :: WarnLogMonad m => m Bool
hasWarnings = getWarnings >>= return . not . isEmptyBag

-- | A monad that has all the features needed by GHC API calls.
--
-- In short, a GHC monad
--
--   - allows embedding of IO actions,
--
--   - can log warnings,
--
--   - allows handling of (extensible) exceptions, and
--
--   - maintains a current session.
--
-- If you do not use 'Ghc' or 'GhcT', make sure to call 'GHC.initGhcMonad'
-- before any call to the GHC API functions can occur.
--
class (Functor m, MonadIO m, WarnLogMonad m, ExceptionMonad m)
    => GhcMonad m where
  getSession :: m HscEnv
  setSession :: HscEnv -> m ()

-- | Call the argument with the current session.
withSession :: GhcMonad m => (HscEnv -> m a) -> m a
withSession f = getSession >>= f

-- | Set the current session to the result of applying the current session to
-- the argument.
modifySession :: GhcMonad m => (HscEnv -> HscEnv) -> m ()
modifySession f = do h <- getSession
                     setSession $! f h

Thomas Schilling's avatar
Thomas Schilling committed
298 299 300 301 302 303 304 305 306 307
withSavedSession :: GhcMonad m => m a -> m a
withSavedSession m = do
  saved_session <- getSession
  m `gfinally` setSession saved_session

-- | Call an action with a temporarily modified Session.
withTempSession :: GhcMonad m => (HscEnv -> HscEnv) -> m a -> m a
withTempSession f m =
  withSavedSession $ modifySession f >> m

308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
-- | A minimal implementation of a 'GhcMonad'.  If you need a custom monad,
-- e.g., to maintain additional state consider wrapping this monad or using
-- 'GhcT'.
newtype Ghc a = Ghc { unGhc :: Session -> IO a }

instance Functor Ghc where
  fmap f m = Ghc $ \s -> f `fmap` unGhc m s

instance Monad Ghc where
  return a = Ghc $ \_ -> return a
  m >>= g  = Ghc $ \s -> do a <- unGhc m s; unGhc (g a) s

instance MonadIO Ghc where
  liftIO ioA = Ghc $ \_ -> ioA

instance ExceptionMonad Ghc where
  gcatch act handle =
      Ghc $ \s -> unGhc act s `gcatch` \e -> unGhc (handle e) s
326 327 328
  gblock (Ghc m)   = Ghc $ \s -> gblock (m s)
  gunblock (Ghc m) = Ghc $ \s -> gunblock (m s)

329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
instance WarnLogMonad Ghc where
  setWarnings warns = Ghc $ \(Session _ wref) -> writeIORef wref warns
  -- | Return 'Warnings' accumulated so far.
  getWarnings       = Ghc $ \(Session _ wref) -> readIORef wref

instance GhcMonad Ghc where
  getSession = Ghc $ \(Session r _) -> readIORef r
  setSession s' = Ghc $ \(Session r _) -> writeIORef r s'

-- | A monad transformer to add GHC specific features to another monad.
--
-- Note that the wrapped monad must support IO and handling of exceptions.
newtype GhcT m a = GhcT { unGhcT :: Session -> m a }
liftGhcT :: Monad m => m a -> GhcT m a
liftGhcT m = GhcT $ \_ -> m
344

345 346 347 348 349 350 351 352 353 354 355 356 357
instance Functor m => Functor (GhcT m) where
  fmap f m = GhcT $ \s -> f `fmap` unGhcT m s

instance Monad m => Monad (GhcT m) where
  return x = GhcT $ \_ -> return x
  m >>= k  = GhcT $ \s -> do a <- unGhcT m s; unGhcT (k a) s

instance MonadIO m => MonadIO (GhcT m) where
  liftIO ioA = GhcT $ \_ -> liftIO ioA

instance ExceptionMonad m => ExceptionMonad (GhcT m) where
  gcatch act handle =
      GhcT $ \s -> unGhcT act s `gcatch` \e -> unGhcT (handle e) s
358 359
  gblock (GhcT m) = GhcT $ \s -> gblock (m s)
  gunblock (GhcT m) = GhcT $ \s -> gunblock (m s)
360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391

instance MonadIO m => WarnLogMonad (GhcT m) where
  setWarnings warns = GhcT $ \(Session _ wref) -> liftIO $ writeIORef wref warns
  -- | Return 'Warnings' accumulated so far.
  getWarnings       = GhcT $ \(Session _ wref) -> liftIO $ readIORef wref

instance (Functor m, ExceptionMonad m, MonadIO m) => GhcMonad (GhcT m) where
  getSession = GhcT $ \(Session r _) -> liftIO $ readIORef r
  setSession s' = GhcT $ \(Session r _) -> liftIO $ writeIORef r s'

-- | Lift an IO action returning errors messages into a 'GhcMonad'.
--
-- In order to reduce dependencies to other parts of the compiler, functions
-- outside the "main" parts of GHC return warnings and errors as a parameter
-- and signal success via by wrapping the result in a 'Maybe' type.  This
-- function logs the returned warnings and propagates errors as exceptions
-- (of type 'SourceError').
--
-- This function assumes the following invariants:
--
--  1. If the second result indicates success (is of the form 'Just x'),
--     there must be no error messages in the first result.
--
--  2. If there are no error messages, but the second result indicates failure
--     there should be warnings in the first result.  That is, if the action
--     failed, it must have been due to the warnings (i.e., @-Werror@).
ioMsgMaybe :: GhcMonad m =>
              IO (Messages, Maybe a) -> m a
ioMsgMaybe ioA = do
  ((warns,errs), mb_r) <- liftIO ioA
  logWarnings warns
  case mb_r of
392
    Nothing -> liftIO $ throwIO (mkSrcErr errs)
393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421
    Just r  -> ASSERT( isEmptyBag errs ) return r

-- | Lift a non-failing IO action into a 'GhcMonad'.
--
-- Like 'ioMsgMaybe', but assumes that the action will never return any error
-- messages.
ioMsg :: GhcMonad m => IO (Messages, a) -> m a
ioMsg ioA = do
    ((warns,errs), r) <- liftIO ioA
    logWarnings warns
    ASSERT( isEmptyBag errs ) return r

-- | Reflect a computation in the 'Ghc' monad into the 'IO' monad.
--
-- You can use this to call functions returning an action in the 'Ghc' monad
-- inside an 'IO' action.  This is needed for some (too restrictive) callback
-- arguments of some library functions:
--
-- > libFunc :: String -> (Int -> IO a) -> IO a
-- > ghcFunc :: Int -> Ghc a
-- >
-- > ghcFuncUsingLibFunc :: String -> Ghc a -> Ghc a
-- > ghcFuncUsingLibFunc str =
-- >   reifyGhc $ \s ->
-- >     libFunc $ \i -> do
-- >       reflectGhc (ghcFunc i) s
--
reflectGhc :: Ghc a -> Session -> IO a
reflectGhc m = unGhc m
422

423 424 425
-- > Dual to 'reflectGhc'.  See its documentation.
reifyGhc :: (Session -> IO a) -> Ghc a
reifyGhc act = Ghc $ act
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443

handleFlagWarnings :: GhcMonad m => DynFlags -> [Located String] -> m ()
handleFlagWarnings dflags warns
 = when (dopt Opt_WarnDeprecatedFlags dflags)
        (handleFlagWarnings' dflags warns)

handleFlagWarnings' :: GhcMonad m => DynFlags -> [Located String] -> m ()
handleFlagWarnings' _ [] = return ()
handleFlagWarnings' dflags warns
 = do -- It would be nicer if warns :: [Located Message], but that has circular
      -- import problems.
      logWarnings $ listToBag (map mkFlagWarning warns)
      when (dopt Opt_WarnIsError dflags) $
        liftIO $ throwIO $ mkSrcErr emptyBag

mkFlagWarning :: Located String -> WarnMsg
mkFlagWarning (L loc warn)
 = mkPlainWarnMsg loc (text warn)
444 445
\end{code}

446
\begin{code}
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
-- | These functions are called in various places of the GHC API.
--
-- API clients can override any of these callbacks to change GHC's default
-- behaviour.
data GhcApiCallbacks
  = GhcApiCallbacks {

    -- | Called by 'load' after the compilating of each module.
    --
    -- The default implementation simply prints all warnings and errors to
    -- @stderr@.  Don't forget to call 'clearWarnings' when implementing your
    -- own call.
    --
    -- The first argument is the module that was compiled.
    --
    -- The second argument is @Nothing@ if no errors occured, but there may
    -- have been warnings.  If it is @Just err@ at least one error has
    -- occured.  If 'srcErrorMessages' is empty, compilation failed due to
    -- @-Werror@.
    reportModuleCompilationResult :: GhcMonad m =>
                                     ModSummary -> Maybe SourceError
                                  -> m ()
  }

-- | Temporarily modify the callbacks.  After the action is executed all
-- callbacks are reset (not, however, any other modifications to the session
-- state.)
withLocalCallbacks :: GhcMonad m =>
                      (GhcApiCallbacks -> GhcApiCallbacks)
                   -> m a -> m a
withLocalCallbacks f m = do
  hsc_env <- getSession
  let cb0 = hsc_callbacks hsc_env
  let cb' = f cb0
  setSession (hsc_env { hsc_callbacks = cb' `seq` cb' })
  r <- m
483 484
  hsc_env' <- getSession
  setSession (hsc_env' { hsc_callbacks = cb0 })
485 486 487 488 489 490
  return r

\end{code}

\begin{code}
-- | Hscenv is like 'Session', except that some of the fields are immutable.
491 492 493 494 495 496 497 498 499
-- An HscEnv is used to compile a single module from plain Haskell source
-- code (after preprocessing) to either C, assembly or C--.  Things like
-- the module graph don't change during a single compilation.
--
-- Historical note: \"hsc\" used to be the name of the compiler binary,
-- when there was a separate driver and compiler.  To compile a single
-- module, the driver would invoke hsc on the source code... so nowadays
-- we think of hsc as the layer of the compiler that deals with compiling
-- a single module.
500
data HscEnv 
501 502
  = HscEnv { 
	hsc_dflags :: DynFlags,
503
		-- ^ The dynamic flag settings
504

505 506 507
        hsc_callbacks :: GhcApiCallbacks,
                -- ^ Callbacks for the GHC API.

508
	hsc_targets :: [Target],
509
		-- ^ The targets (or roots) of the current session
510

511
	hsc_mod_graph :: ModuleGraph,
512
		-- ^ The module graph of the current session
513 514

	hsc_IC :: InteractiveContext,
515
		-- ^ The context for evaluating interactive statements
516 517

	hsc_HPT    :: HomePackageTable,
518 519
		-- ^ The home package table describes already-compiled
		-- home-package modules, /excluding/ the module we 
520 521 522
		-- are compiling right now.
		-- (In one-shot mode the current module is the only
		--  home-package module, so hsc_HPT is empty.  All other
523
		--  modules count as \"external-package\" modules.
524
		--  However, even in GHCi mode, hi-boot interfaces are
525
		--  demand-loaded into the external-package table.)
526
		--
527
		-- 'hsc_HPT' is not mutable because we only demand-load 
528
		-- external packages; the home package is eagerly 
529
		-- loaded, module by module, by the compilation manager.
530
		--	
531
		-- The HPT may contain modules compiled earlier by @--make@
532
		-- but not actually below the current module in the dependency
533 534 535
		-- graph.

		-- (This changes a previous invariant: changed Jan 05.)
536
	
537
	hsc_EPS	:: {-# UNPACK #-} !(IORef ExternalPackageState),
538 539 540 541
	        -- ^ Information about the currently loaded external packages.
	        -- This is mutable because packages will be demand-loaded during
	        -- a compilation run as required.
	
542
	hsc_NC	:: {-# UNPACK #-} !(IORef NameCache),
543 544
		-- ^ As with 'hsc_EPS', this is side-effected by compiling to
		-- reflect sucking in interface files.  They cache the state of
545 546
		-- external interface files, in effect.

Simon Marlow's avatar
Simon Marlow committed
547
	hsc_FC   :: {-# UNPACK #-} !(IORef FinderCache),
548
	        -- ^ The cached result of performing finding in the file system
Simon Marlow's avatar
Simon Marlow committed
549
	hsc_MLC  :: {-# UNPACK #-} !(IORef ModLocationCache),
550 551
		-- ^ This caches the location of modules, so we don't have to 
		-- search the filesystem multiple times. See also 'hsc_FC'.
Simon Marlow's avatar
Simon Marlow committed
552

dias@eecs.harvard.edu's avatar
dias@eecs.harvard.edu committed
553
        hsc_OptFuel :: OptFuelState,
554
                -- ^ Settings to control the use of \"optimization fuel\":
dias@eecs.harvard.edu's avatar
dias@eecs.harvard.edu committed
555 556 557
                -- by limiting the number of transformations,
                -- we can use binary search to help find compiler bugs.

558
        hsc_type_env_var :: Maybe (Module, IORef TypeEnv),
559 560 561
                -- ^ Used for one-shot compilation only, to initialise
                -- the 'IfGblEnv'. See 'TcRnTypes.tcg_type_env_var' for 
                -- 'TcRunTypes.TcGblEnv'
562

563
        hsc_global_rdr_env :: GlobalRdrEnv,
564 565 566 567 568
                -- ^ A mapping from 'RdrName's that are in global scope during
                -- the compilation of the current file to more detailed
                -- information about those names. Not necessarily just the
                -- names directly imported by the module being compiled!
        
569
        hsc_global_type_env :: TypeEnv
570 571 572
                -- ^ Typing information about all those things in global scope.
                -- Not necessarily just the things directly imported by the module 
                -- being compiled!
573
 }
574 575 576

hscEPS :: HscEnv -> IO ExternalPackageState
hscEPS hsc_env = readIORef (hsc_EPS hsc_env)
577

578 579 580 581 582 583
-- | A compilation target.
--
-- A target may be supplied with the actual text of the
-- module.  If so, use this instead of the file contents (this
-- is for use in an IDE where the file hasn't been saved by
-- the user yet).
Simon Marlow's avatar
Simon Marlow committed
584
data Target = Target
585 586 587 588 589
      { targetId           :: TargetId  -- ^ module or filename
      , targetAllowObjCode :: Bool      -- ^ object code allowed?
      , targetContents     :: Maybe (StringBuffer,ClockTime)
                                        -- ^ in-memory text buffer?
      }
590 591

data TargetId
Simon Marlow's avatar
Simon Marlow committed
592
  = TargetModule ModuleName
593 594 595 596 597 598
	-- ^ A module name: search for the file
  | TargetFile FilePath (Maybe Phase)
	-- ^ A filename: preprocess & parse it to find the module name.
	-- If specified, the Phase indicates how to compile this file
	-- (which phase to start from).  Nothing indicates the starting phase
	-- should be determined from the suffix of the filename.
599
  deriving Eq
600 601

pprTarget :: Target -> SDoc
Simon Marlow's avatar
Simon Marlow committed
602 603
pprTarget (Target id obj _) = 
   (if obj then char '*' else empty) <> pprTargetId id
604

Ian Lynagh's avatar
Ian Lynagh committed
605 606 607
instance Outputable Target where
    ppr = pprTarget

Simon Marlow's avatar
Simon Marlow committed
608
pprTargetId :: TargetId -> SDoc
609
pprTargetId (TargetModule m) = ppr m
610
pprTargetId (TargetFile f _) = text f
611

Ian Lynagh's avatar
Ian Lynagh committed
612 613 614
instance Outputable TargetId where
    ppr = pprTargetId

615
-- | Helps us find information about modules in the home package
Simon Marlow's avatar
Simon Marlow committed
616
type HomePackageTable  = ModuleNameEnv HomeModInfo
617
	-- Domain = modules in the home package that have been fully compiled
Simon Marlow's avatar
Simon Marlow committed
618
	-- "home" package name cached here for convenience
619 620

-- | Helps us find information about modules in the imported packages
621 622
type PackageIfaceTable = ModuleEnv ModIface
	-- Domain = modules in the imported packages
623

Simon Marlow's avatar
Simon Marlow committed
624
emptyHomePackageTable :: HomePackageTable
Simon Marlow's avatar
Simon Marlow committed
625
emptyHomePackageTable  = emptyUFM
Simon Marlow's avatar
Simon Marlow committed
626 627

emptyPackageIfaceTable :: PackageIfaceTable
628 629
emptyPackageIfaceTable = emptyModuleEnv

630
-- | Information about modules in the package being compiled
631
data HomeModInfo 
632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656
  = HomeModInfo {
      hm_iface    :: !ModIface,
        -- ^ The basic loaded interface file: every loaded module has one of
        -- these, even if it is imported from another package
      hm_details  :: !ModDetails,
        -- ^ Extra information that has been created from the 'ModIface' for
	-- the module, typically during typechecking
      hm_linkable :: !(Maybe Linkable)
        -- ^ The actual artifact we would like to link to access things in
	-- this module.
	--
	-- 'hm_linkable' might be Nothing:
	--
	--   1. If this is an .hs-boot module
	--
	--   2. Temporarily during compilation if we pruned away
	--      the old linkable because it was out of date.
	--
	-- After a complete compilation ('GHC.load'), all 'hm_linkable' fields
	-- in the 'HomePackageTable' will be @Just@.
	--
	-- When re-linking a module ('HscMain.HscNoRecomp'), we construct the
	-- 'HomeModInfo' by building a new 'ModDetails' from the old
	-- 'ModIface' (only).
    }
657

658 659
-- | Find the 'ModIface' for a 'Module', searching in both the loaded home
-- and external package module information
Simon Marlow's avatar
Simon Marlow committed
660 661 662 663 664 665 666
lookupIfaceByModule
	:: DynFlags
	-> HomePackageTable
	-> PackageIfaceTable
	-> Module
	-> Maybe ModIface
lookupIfaceByModule dflags hpt pit mod
667 668 669 670 671
  | modulePackageId mod == thisPackage dflags
  = 	-- The module comes from the home package, so look first
	-- in the HPT.  If it's not from the home package it's wrong to look
	-- in the HPT, because the HPT is indexed by *ModuleName* not Module
    fmap hm_iface (lookupUFM hpt (moduleName mod)) 
672
    `mplus` lookupModuleEnv pit mod
673 674 675 676 677 678 679

  | otherwise = lookupModuleEnv pit mod		-- Look in PIT only 

-- If the module does come from the home package, why do we look in the PIT as well?
-- (a) In OneShot mode, even home-package modules accumulate in the PIT
-- (b) Even in Batch (--make) mode, there is *one* case where a home-package
--     module is in the PIT, namely GHC.Prim when compiling the base package.
680
-- We could eliminate (b) if we wanted, by making GHC.Prim belong to a package
681
-- of its own, but it doesn't seem worth the bother.
682
\end{code}
683

684 685

\begin{code}
686
hptInstances :: HscEnv -> (ModuleName -> Bool) -> ([Instance], [FamInst])
687
-- ^ Find all the instance declarations (of classes and families) that are in
688
-- modules imported by this one, directly or indirectly, and are in the Home
689
-- Package Table.  This ensures that we don't see instances from modules @--make@
690
-- compiled before this one, but which are not below this one.
691
hptInstances hsc_env want_this_module
692 693 694 695 696 697 698 699 700 701 702 703
  = let (insts, famInsts) = unzip $ flip hptAllThings hsc_env $ \mod_info -> do
                guard (want_this_module (moduleName (mi_module (hm_iface mod_info))))
                let details = hm_details mod_info
                return (md_insts details, md_fam_insts details)
    in (concat insts, concat famInsts)

hptVectInfo :: HscEnv -> VectInfo
-- ^ Get the combined VectInfo of all modules in the home package table.  In
-- contrast to instances and rules, we don't care whether the modules are
-- \"below\" us in the dependency sense.  The VectInfo of those modules not \"below\" 
-- us does not affect the compilation of the current module.
hptVectInfo = concatVectInfo . hptAllThings ((: []) . md_vect_info . hm_details)
704

Simon Marlow's avatar
Simon Marlow committed
705
hptRules :: HscEnv -> [(ModuleName, IsBootInterface)] -> [CoreRule]
706 707 708
-- ^ Get rules from modules \"below\" this one (in the dependency sense)
hptRules = hptSomeThingsBelowUs (md_rules . hm_details) False

709 710 711 712 713 714

hptAnns :: HscEnv -> Maybe [(ModuleName, IsBootInterface)] -> [Annotation]
-- ^ Get annotations from modules \"below\" this one (in the dependency sense)
hptAnns hsc_env (Just deps) = hptSomeThingsBelowUs (md_anns . hm_details) False hsc_env deps
hptAnns hsc_env Nothing = hptAllThings (md_anns . hm_details) hsc_env

715 716 717 718 719
hptAllThings :: (HomeModInfo -> [a]) -> HscEnv -> [a]
hptAllThings extract hsc_env = concatMap extract (eltsUFM (hsc_HPT hsc_env))

hptSomeThingsBelowUs :: (HomeModInfo -> [a]) -> Bool -> HscEnv -> [(ModuleName, IsBootInterface)] -> [a]
-- Get things from modules \"below\" this one (in the dependency sense)
720
-- C.f Inst.hptInstances
721 722
hptSomeThingsBelowUs extract include_hi_boot hsc_env deps
 | isOneShot (ghcMode (hsc_dflags hsc_env)) = []
723 724 725 726
  | otherwise
  = let 
	hpt = hsc_HPT hsc_env
    in
727
    [ thing
728
    |	-- Find each non-hi-boot module below me
729 730
      (mod, is_boot_mod) <- deps
    , include_hi_boot || not is_boot_mod
731

732
	-- unsavoury: when compiling the base package with --make, we
733
	-- sometimes try to look up RULES etc for GHC.Prim.  GHC.Prim won't
734 735 736
	-- be in the HPT, because we never compile it; it's in the EPT
	-- instead.  ToDo: clean up, and remove this slightly bogus
	-- filter:
Simon Marlow's avatar
Simon Marlow committed
737
    , mod /= moduleName gHC_PRIM
738

739
	-- Look it up in the HPT
740 741 742
    , let things = case lookupUFM hpt mod of
		    Just info -> extract info
		    Nothing -> pprTrace "WARNING in hptSomeThingsBelowUs" msg [] 
Ian Lynagh's avatar
Ian Lynagh committed
743 744
	  msg = vcat [ptext (sLit "missing module") <+> ppr mod,
		      ptext (sLit "Probable cause: out-of-date interface files")]
745
			-- This really shouldn't happen, but see Trac #962
746 747

	-- And get its dfuns
748
    , thing <- things ]
749
\end{code}
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
750

751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774
%************************************************************************
%*									*
\subsection{Dealing with Annotations}
%*									*
%************************************************************************

\begin{code}
prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv
-- ^ Deal with gathering annotations in from all possible places 
--   and combining them into a single 'AnnEnv'
prepareAnnotations hsc_env mb_guts
  = do { eps <- hscEPS hsc_env
       ; let -- Extract annotations from the module being compiled if supplied one
            mb_this_module_anns = fmap (mkAnnEnv . mg_anns) mb_guts
        -- Extract dependencies of the module if we are supplied one,
        -- otherwise load annotations from all home package table
        -- entries regardless of dependency ordering.
            home_pkg_anns  = (mkAnnEnv . hptAnns hsc_env) $ fmap (dep_mods . mg_deps) mb_guts
            other_pkg_anns = eps_ann_env eps
            ann_env        = foldl1' plusAnnEnv $ catMaybes [mb_this_module_anns, 
                                                             Just home_pkg_anns, 
                                                             Just other_pkg_anns]

       ; return ann_env }
775 776
\end{code}

Simon Marlow's avatar
Simon Marlow committed
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796
%************************************************************************
%*									*
\subsection{The Finder cache}
%*									*
%************************************************************************

\begin{code}
-- | The 'FinderCache' maps home module names to the result of
-- searching for that module.  It records the results of searching for
-- modules along the search path.  On @:load@, we flush the entire
-- contents of this cache.
--
-- Although the @FinderCache@ range is 'FindResult' for convenience ,
-- in fact it will only ever contain 'Found' or 'NotFound' entries.
--
type FinderCache = ModuleNameEnv FindResult

-- | The result of searching for an imported module.
data FindResult
  = Found ModLocation Module
797
	-- ^ The module was found
Simon Marlow's avatar
Simon Marlow committed
798
  | NoPackage PackageId
799
	-- ^ The requested package was not found
Simon Marlow's avatar
Simon Marlow committed
800
  | FoundMultiple [PackageId]
801
	-- ^ _Error_: both in multiple packages
802 803 804 805 806 807
  | NotFound [FilePath] (Maybe PackageId) [PackageId] [PackageId]
	-- ^ The module was not found, including either
        --    * the specified places were searched
        --    * the package that this module should have been in
        --    * list of packages in which the module was hidden,
        --    * list of hidden packages containing this module
Simon Marlow's avatar
Simon Marlow committed
808
  | NotFoundInPackage PackageId
809
	-- ^ The module was not found in this package
Simon Marlow's avatar
Simon Marlow committed
810 811 812 813 814 815

-- | Cache that remembers where we found a particular module.  Contains both
-- home modules and package modules.  On @:load@, only home modules are
-- purged from this cache.
type ModLocationCache = ModuleEnv ModLocation
\end{code}
816

817 818
%************************************************************************
%*									*
819
\subsection{Symbol tables and Module details}
820 821 822 823
%*									*
%************************************************************************

\begin{code}
824 825 826 827 828 829 830 831 832
-- | A 'ModIface' plus a 'ModDetails' summarises everything we know 
-- about a compiled module.  The 'ModIface' is the stuff *before* linking,
-- and can be written out to an interface file. The 'ModDetails is after 
-- linking and can be completely recovered from just the 'ModIface'.
-- 
-- When we read an interface file, we also construct a 'ModIface' from it,
-- except that we explicitly make the 'mi_decls' and a few other fields empty;
-- as when reading we consolidate the declarations etc. into a number of indexed
-- maps and environments in the 'ExternalPackageState'.
833 834
data ModIface 
   = ModIface {
835 836 837
        mi_module   :: !Module,             -- ^ Name of the module we are for
        mi_iface_hash :: !Fingerprint,      -- ^ Hash of the whole interface
        mi_mod_hash :: !Fingerprint,	    -- ^ Hash of the ABI only
838

839 840 841
        mi_orphan   :: !WhetherHasOrphans,  -- ^ Whether this module has orphans
        mi_finsts   :: !WhetherHasFamInst,  -- ^ Whether this module has family instances
	mi_boot	    :: !IsBootInterface,    -- ^ Read from an hi-boot file?
842

843
	mi_deps	    :: Dependencies,
Simon Marlow's avatar
Simon Marlow committed
844 845 846 847
	        -- ^ The dependencies of the module.  This is
		-- consulted for directly-imported modules, but not
		-- for anything else (hence lazy)

848 849
        mi_usages   :: [Usage],
                -- ^ Usages; kept sorted so that it's easy to decide
850
		-- whether to write a new iface file (changing usages
851
		-- doesn't affect the hash of this module)
852
        
853
		-- NOT STRICT!  we read this field lazily from the interface file
854
		-- It is *only* consulted by the recompilation checker
855

856 857 858
		-- Exports
		-- Kept sorted by (mod,occ), to make version comparisons easier
        mi_exports  :: ![IfaceExport],
859 860 861 862
                -- ^ Records the modules that are the declaration points for things
                -- exported by this module, and the 'OccName's of those things
        
        mi_exp_hash :: !Fingerprint,	-- ^ Hash of export list
863

864
        mi_fixities :: [(OccName,Fixity)],
865 866
                -- ^ Fixities
        
867
		-- NOT STRICT!  we read this field lazily from the interface file
868

Ian Lynagh's avatar
Ian Lynagh committed
869
	mi_warns  :: Warnings,
870 871
		-- ^ Warnings
		
872
		-- NOT STRICT!  we read this field lazily from the interface file
873

874 875 876 877 878
	mi_anns  :: [IfaceAnnotation],
	        -- ^ Annotations
	
		-- NOT STRICT!  we read this field lazily from the interface file

879
		-- Type, class and variable declarations
880
		-- The hash of an Id changes if its fixity or deprecations change
881 882
		--	(as well as its type of course)
		-- Ditto data constructors, class operations, except that 
883
		-- the hash of the parent class/tycon changes
884
	mi_decls :: [(Fingerprint,IfaceDecl)],	-- ^ Sorted type, variable, class etc. declarations
885

886
        mi_globals  :: !(Maybe GlobalRdrEnv),
887 888
		-- ^ Binds all the things defined at the top level in
		-- the /original source/ code for this module. which
889 890 891 892 893 894 895
		-- is NOT the same as mi_exports, nor mi_decls (which
		-- may contains declarations for things not actually
		-- defined by the user).  Used for GHCi and for inspecting
		-- the contents of modules via the GHC API only.
		--
		-- (We need the source file to figure out the
		-- top-level environment, if we didn't compile this module
896
		-- from source then this field contains @Nothing@).
897 898
		--
		-- Strictly speaking this field should live in the
899
		-- 'HomeModInfo', but that leads to more plumbing.
900

901
		-- Instance declarations and rules
902 903 904 905 906
	mi_insts     :: [IfaceInst],			-- ^ Sorted class instance
	mi_fam_insts :: [IfaceFamInst],			-- ^ Sorted family instances
	mi_rules     :: [IfaceRule],			-- ^ Sorted rules
	mi_orphan_hash :: !Fingerprint,	-- ^ Hash for orphan rules and 
					-- class and family instances
907
					-- combined
908

909
        mi_vect_info :: !IfaceVectInfo, -- ^ Vectorisation information
910

911 912 913
		-- Cached environments for easy lookup
		-- These are computed (lazily) from other fields
		-- and are not put into the interface file
914 915
	mi_warn_fn  :: Name -> Maybe WarningTxt,        -- ^ Cached lookup for 'mi_warns'
	mi_fix_fn  :: OccName -> Fixity,	        -- ^ Cached lookup for 'mi_fixities'
916
	mi_hash_fn :: OccName -> Maybe (OccName, Fingerprint),
917 918
                        -- ^ Cached lookup for 'mi_decls'.
			-- The @Nothing@ in 'mi_hash_fn' means that the thing
919
			-- isn't in decls. It's useful to know that when
920
			-- seeing if we are up to date wrt. the old interface.
921
                        -- The 'OccName' is the parent of the name, if it has one.
922
	mi_hpc    :: !AnyHpcUsage
923
	        -- ^ True if this program uses Hpc at any point in the program.
924
     }
925

926 927 928
-- | The 'ModDetails' is essentially a cache for information in the 'ModIface'
-- for home modules only. Information relating to packages will be loaded into
-- global environments in 'ExternalPackageState'.
929 930
data ModDetails
   = ModDetails {
931 932
	-- The next two fields are created by the typechecker
	md_exports   :: [AvailInfo],
933 934
        md_types     :: !TypeEnv,       -- ^ Local type environment for this particular module
        md_insts     :: ![Instance],    -- ^ 'DFunId's for the instances in this module
935
        md_fam_insts :: ![FamInst],
936
        md_rules     :: ![CoreRule],    -- ^ Domain may include 'Id's from other modules
937 938
        md_anns      :: ![Annotation],  -- ^ Annotations present in this module: currently 
                                        -- they only annotate things also declared in this module
939
        md_vect_info :: !VectInfo       -- ^ Module vectorisation information
940
     }
941

Simon Marlow's avatar
Simon Marlow committed
942
emptyModDetails :: ModDetails
943
emptyModDetails = ModDetails { md_types = emptyTypeEnv,
944
			       md_exports = [],
945 946
			       md_insts     = [],
			       md_rules     = [],
mnislaih's avatar
mnislaih committed
947
			       md_fam_insts = [],
948
                               md_anns      = [],
chak@cse.unsw.edu.au.'s avatar
chak@cse.unsw.edu.au. committed
949 950
                               md_vect_info = noVectInfo
                             } 
951

952
-- | Records the modules directly imported by a module for extracting e.g. usage information
953
type ImportedMods = ModuleEnv [(ModuleName, Bool, SrcSpan)]
954 955
-- TODO: we are not actually using the codomain of this type at all, so it can be
-- replaced with ModuleEnv ()
Simon Marlow's avatar
Simon Marlow committed
956

957 958 959 960
-- | A ModGuts is carried through the compiler, accumulating stuff as it goes
-- There is only one ModGuts at any time, the one for the module
-- being compiled right now.  Once it is compiled, a 'ModIface' and 
-- 'ModDetails' are extracted and the ModGuts is dicarded.
961 962
data ModGuts
  = ModGuts {
963 964 965 966 967 968 969 970
        mg_module    :: !Module,         -- ^ Module being compiled
	mg_boot      :: IsBootInterface, -- ^ Whether it's an hs-boot module
	mg_exports   :: ![AvailInfo],	 -- ^ What it exports
	mg_deps	     :: !Dependencies,	 -- ^ What it depends on, directly or
	                                 -- otherwise
	mg_dir_imps  :: !ImportedMods,	 -- ^ Directly-imported modules; used to
					 -- generate initialisation code
	mg_used_names:: !NameSet,	 -- ^ What the module needed (used in 'MkIface.mkIface')
971

972
        mg_rdr_env   :: !GlobalRdrEnv,	 -- ^ Top-level lexical environment
973

974
	-- These fields all describe the things **declared in this module**
975 976 977 978 979 980 981 982 983 984 985 986
	mg_fix_env   :: !FixityEnv,	 -- ^ Fixities declared in this module
	                                 -- TODO: I'm unconvinced this is actually used anywhere
	mg_types     :: !TypeEnv,        -- ^ Types declared in this module
	mg_insts     :: ![Instance],	 -- ^ Class instances declared in this module
	mg_fam_insts :: ![FamInst],	 -- ^ Family instances declared in this module
        mg_rules     :: ![CoreRule],	 -- ^ Before the core pipeline starts, contains 
                                         -- rules declared in this module. After the core
                                         -- pipeline starts, it is changed to contain all
                                         -- known rules for those things imported
	mg_binds     :: ![CoreBind],	 -- ^ Bindings for this module
	mg_foreign   :: !ForeignStubs,   -- ^ Foreign exports declared in this module
	mg_warns     :: !Warnings,	 -- ^ Warnings declared in the module
987
	mg_anns      :: [Annotation],    -- ^ Annotations declared in this module
988 989 990
	mg_hpc_info  :: !HpcInfo,        -- ^ Coverage tick boxes in the module
        mg_modBreaks :: !ModBreaks,      -- ^ Breakpoints for the module
        mg_vect_info :: !VectInfo,       -- ^ Pool of vectorised declarations in the module
991 992 993 994 995 996

	-- The next two fields are unusual, because they give instance
	-- environments for *all* modules in the home package, including
	-- this module, rather than for *just* this module.  
	-- Reason: when looking up an instance we don't want to have to
	--	  look at each module in the home package in turn
Thomas Schilling's avatar
Thomas Schilling committed
997
	mg_inst_env     :: InstEnv,
998 999
        -- ^ Class instance environment from /home-package/ modules (including
	-- this one); c.f. 'tcg_inst_env'
Thomas Schilling's avatar
Thomas Schilling committed
1000 1001
	mg_fam_inst_env :: FamInstEnv
        -- ^ Type-family instance enviroment for /home-package/ modules
1002
	-- (including this one); c.f. 'tcg_fam_inst_env'
1003 1004
    }

1005 1006 1007 1008 1009 1010 1011 1012
-- The ModGuts takes on several slightly different forms:
--
-- After simplification, the following fields change slightly:
--	mg_rules	Orphan rules only (local ones now attached to binds)
--	mg_binds	With rules attached

-- | A CoreModule consists of just the fields of a 'ModGuts' that are needed for
-- the 'GHC.compileToCoreModule' interface.
1013 1014
data CoreModule
  = CoreModule {
1015
      -- | Module name
1016
      cm_module   :: !Module,
1017
      -- | Type environment for types declared in this module
1018
      cm_types    :: !TypeEnv,
1019
      -- | Declarations
1020
      cm_binds    :: [CoreBind],
1021
      -- | Imports
1022
      cm_imports  :: ![Module]
1023 1024 1025 1026 1027 1028
    }

instance Outputable CoreModule where
   ppr (CoreModule {cm_module = mn, cm_types = te, cm_binds = cb}) =
      text "%module" <+> ppr mn <+> ppr te $$ vcat (map ppr cb)

1029
-- The ModGuts takes on several slightly different forms:
1030
--
1031 1032 1033 1034 1035
-- After simplification, the following fields change slightly:
--	mg_rules	Orphan rules only (local ones now attached to binds)
--	mg_binds	With rules attached


1036 1037 1038 1039 1040
---------------------------------------------------------
-- The Tidy pass forks the information about this module: 
--	* one lot goes to interface file generation (ModIface)
--	  and later compilations (ModDetails)
--	* the other lot goes to code generation (CgGuts)
1041 1042

-- | A restricted form of 'ModGuts' for code generation purposes
1043 1044
data CgGuts 
  = CgGuts {
1045
	cg_module   :: !Module, -- ^ Module being compiled
1046

1047
	cg_tycons   :: [TyCon],
1048
		-- ^ Algebraic data types (including ones that started
1049
		-- life as classes); generate constructors and info
1050
		-- tables. Include