    -----------------------------------------------------------------------------
    --
    -- (c) The University of Glasgow -2006
    --
    -- Code generation relaed to GpH
    -- 	(a) parallel
    --	(b) GranSim
    --
    -----------------------------------------------------------------------------

    module StgCmmGran (
    	staticGranHdr,staticParHdr,
    	granThunk, granYield,
    	doGranAllocate
      ) where

    -- This entire module consists of no-op stubs at the moment
    -- GranSim worked once, but it certainly doesn't any more
    -- I've left the calls, though, in case anyone wants to resurrect it

    import StgCmmMonad
    import Cmm

    staticGranHdr :: [CmmLit]
    staticGranHdr = []

    staticParHdr :: [CmmLit]
    staticParHdr = []

    doGranAllocate :: VirtualHpOffset -> FCode ()
    -- Must be lazy in the amount of allocation
    doGranAllocate _ = return ()

    granYield :: [LocalReg] -> Bool -> FCode ()
    granYield _regs _node_reqd = return ()

    granThunk :: Bool -> FCode ()
    granThunk _node_points = return ()

    -----------------------------------------------------------------
    {-   ------- Everything below here is commented out -------------
    -----------------------------------------------------------------

    -- Parallel header words in a static closure
    staticParHdr :: [CmmLit]
    -- Parallel header words in a static closure
    staticParHdr = []

    staticGranHdr :: [CmmLit]
    -- Gransim header words in a static closure
    staticGranHdr = []

    doGranAllocate :: CmmExpr -> Code
    -- macro DO_GRAN_ALLOCATE
    doGranAllocate hp
      | not opt_GranMacros = nopC
      | otherwise	       = panic "doGranAllocate"

    -------------------------
    granThunk :: Bool -> FCode ()
    -- HWL: insert macros for GrAnSim; 2 versions depending on liveness of node
    -- (we prefer fetchAndReschedule-style context switches to yield ones)
    granThunk node_points
      | node_points = granFetchAndReschedule [] node_points
      | otherwise   = granYield 	         [] node_points

    granFetchAndReschedule :: [(Id,GlobalReg)]  -- Live registers
    		       -> Bool           	-- Node reqd?
    		       -> Code
    -- Emit code for simulating a fetch and then reschedule.
    granFetchAndReschedule regs node_reqd
      | opt_GranMacros && (node `elem` map snd regs || node_reqd)
      = do { fetch
           ; reschedule liveness node_reqd }
      | otherwise
      = nopC
      where
        liveness = mkRegLiveness regs 0 0

    fetch = panic "granFetch"
    	-- Was: absC (CMacroStmt GRAN_FETCH [])
    	--HWL: generate GRAN_FETCH macro for GrAnSim
     	--     currently GRAN_FETCH and GRAN_FETCH_AND_RESCHEDULE are miai

    reschedule liveness node_reqd = panic "granReschedule"
    	-- Was: absC  (CMacroStmt GRAN_RESCHEDULE [
      	--                mkIntCLit (I# (word2Int# liveness_mask)),
        	--		  mkIntCLit (if node_reqd then 1 else 0)])

    -------------------------
    -- The @GRAN_YIELD@ macro is taken from JSM's  code for Concurrent Haskell. It
    -- allows to context-switch at  places where @node@ is  not alive (it uses the
    -- @Continue@ rather  than the @EnterNodeCode@  function in the  RTS). We emit
    -- this kind of macro at the beginning of the following kinds of basic bocks:
    -- \begin{itemize}
    --  \item Slow entry code where node is not alive (see @CgClosure.lhs@). Normally
    --        we use @fetchAndReschedule@ at a slow entry code.
    --  \item Fast entry code (see @CgClosure.lhs@).
    --  \item Alternatives in case expressions (@CLabelledCode@ structures), provided
    --        that they are not inlined (see @CgCases.lhs@). These alternatives will
    --        be turned into separate functions.

    granYield :: [(Id,GlobalReg)]   -- Live registers
              -> Bool               -- Node reqd?
              -> Code

    granYield regs node_reqd
      | opt_GranMacros && node_reqd = yield liveness
      | otherwise			= nopC
      where
         liveness = mkRegLiveness regs 0 0

    yield liveness = panic "granYield"
    	-- Was : absC (CMacroStmt GRAN_YIELD
            --                  [mkIntCLit (I# (word2Int# liveness_mask))])

    -}