diff --git a/compiler/GhclibHsVersions.h b/compiler/GhclibHsVersions.h deleted file mode 100644 --- a/compiler/GhclibHsVersions.h +++ /dev/null @@ -1,65 +0,0 @@ -#pragma once - -#if 0 - -IMPORTANT! If you put extra tabs/spaces in these macro definitions, -you will screw up the layout where they are used in case expressions! - -(This is cpp-dependent, of course) - -#endif - -/* Useful in the headers that we share with the RTS */ -#define COMPILING_GHC 1 - -/* Pull in all the platform defines for this build (foo_TARGET_ARCH etc.) */ -#include "ghc_boot_platform.h" - -/* Pull in the autoconf defines (HAVE_FOO), but don't include - * ghcconfig.h, because that will include ghcplatform.h which has the - * wrong platform settings for the compiler (it has the platform - * settings for the target plat instead). */ -#include "ghcautoconf.h" - -#define GLOBAL_VAR(name,value,ty) \ -{-# NOINLINE name #-}; \ -name :: IORef (ty); \ -name = Util.global (value); - -#define GLOBAL_VAR_M(name,value,ty) \ -{-# NOINLINE name #-}; \ -name :: IORef (ty); \ -name = Util.globalM (value); - - -#define SHARED_GLOBAL_VAR(name,accessor,saccessor,value,ty) \ -{-# NOINLINE name #-}; \ -name :: IORef (ty); \ -name = Util.sharedGlobal (value) (accessor); \ -foreign import ccall unsafe saccessor \ - accessor :: Ptr (IORef a) -> IO (Ptr (IORef a)); - -#define SHARED_GLOBAL_VAR_M(name,accessor,saccessor,value,ty) \ -{-# NOINLINE name #-}; \ -name :: IORef (ty); \ -name = Util.sharedGlobalM (value) (accessor); \ -foreign import ccall unsafe saccessor \ - accessor :: Ptr (IORef a) -> IO (Ptr (IORef a)); - - -#define ASSERT(e) if debugIsOn && not (e) then (assertPanic __FILE__ __LINE__) else -#define ASSERT2(e,msg) if debugIsOn && not (e) then (assertPprPanic __FILE__ __LINE__ (msg)) else -#define WARN( e, msg ) (warnPprTrace (e) __FILE__ __LINE__ (msg)) $ - --- Examples: Assuming flagSet :: String -> m Bool --- --- do { c <- getChar; MASSERT( isUpper c ); ... } --- do { c <- getChar; MASSERT2( isUpper c, text "Bad" ); ... } --- do { str <- getStr; ASSERTM( flagSet str ); .. } --- do { str <- getStr; ASSERTM2( flagSet str, text "Bad" ); .. } --- do { str <- getStr; WARNM2( flagSet str, text "Flag is set" ); .. } -#define MASSERT(e) ASSERT(e) return () -#define MASSERT2(e,msg) ASSERT2(e,msg) return () -#define ASSERTM(e) do { bool <- e; MASSERT(bool) } -#define ASSERTM2(e,msg) do { bool <- e; MASSERT2(bool,msg) } -#define WARNM2(e,msg) do { bool <- e; WARN(bool, msg) return () } diff --git a/compiler/HsVersions.h b/compiler/HsVersions.h new file mode 100644 --- /dev/null +++ b/compiler/HsVersions.h @@ -0,0 +1,65 @@ +#pragma once + +#if 0 + +IMPORTANT! If you put extra tabs/spaces in these macro definitions, +you will screw up the layout where they are used in case expressions! + +(This is cpp-dependent, of course) + +#endif + +/* Useful in the headers that we share with the RTS */ +#define COMPILING_GHC 1 + +/* Pull in all the platform defines for this build (foo_TARGET_ARCH etc.) */ +#include "ghc_boot_platform.h" + +/* Pull in the autoconf defines (HAVE_FOO), but don't include + * ghcconfig.h, because that will include ghcplatform.h which has the + * wrong platform settings for the compiler (it has the platform + * settings for the target plat instead). */ +#include "ghcautoconf.h" + +#define GLOBAL_VAR(name,value,ty) \ +{-# NOINLINE name #-}; \ +name :: IORef (ty); \ +name = Util.global (value); + +#define GLOBAL_VAR_M(name,value,ty) \ +{-# NOINLINE name #-}; \ +name :: IORef (ty); \ +name = Util.globalM (value); + + +#define SHARED_GLOBAL_VAR(name,accessor,saccessor,value,ty) \ +{-# NOINLINE name #-}; \ +name :: IORef (ty); \ +name = Util.sharedGlobal (value) (accessor); \ +foreign import ccall unsafe saccessor \ + accessor :: Ptr (IORef a) -> IO (Ptr (IORef a)); + +#define SHARED_GLOBAL_VAR_M(name,accessor,saccessor,value,ty) \ +{-# NOINLINE name #-}; \ +name :: IORef (ty); \ +name = Util.sharedGlobalM (value) (accessor); \ +foreign import ccall unsafe saccessor \ + accessor :: Ptr (IORef a) -> IO (Ptr (IORef a)); + + +#define ASSERT(e) if debugIsOn && not (e) then (assertPanic __FILE__ __LINE__) else +#define ASSERT2(e,msg) if debugIsOn && not (e) then (assertPprPanic __FILE__ __LINE__ (msg)) else +#define WARN( e, msg ) (warnPprTrace (e) __FILE__ __LINE__ (msg)) $ + +-- Examples: Assuming flagSet :: String -> m Bool +-- +-- do { c <- getChar; MASSERT( isUpper c ); ... } +-- do { c <- getChar; MASSERT2( isUpper c, text "Bad" ); ... } +-- do { str <- getStr; ASSERTM( flagSet str ); .. } +-- do { str <- getStr; ASSERTM2( flagSet str, text "Bad" ); .. } +-- do { str <- getStr; WARNM2( flagSet str, text "Flag is set" ); .. } +#define MASSERT(e) ASSERT(e) return () +#define MASSERT2(e,msg) ASSERT2(e,msg) return () +#define ASSERTM(e) do { bool <- e; MASSERT(bool) } +#define ASSERTM2(e,msg) do { bool <- e; MASSERT2(bool,msg) } +#define WARNM2(e,msg) do { bool <- e; WARN(bool, msg) return () } diff --git a/compiler/basicTypes/Avail.hs b/compiler/basicTypes/Avail.hs --- a/compiler/basicTypes/Avail.hs +++ b/compiler/basicTypes/Avail.hs @@ -4,7 +4,7 @@ -- (c) The University of Glasgow -- -#include "GhclibHsVersions.h" +#include "HsVersions.h" module Avail ( Avails, diff --git a/compiler/basicTypes/ConLike.hs b/compiler/basicTypes/ConLike.hs --- a/compiler/basicTypes/ConLike.hs +++ b/compiler/basicTypes/ConLike.hs @@ -24,7 +24,7 @@ , conLikeIsInfix ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/DataCon.hs b/compiler/basicTypes/DataCon.hs --- a/compiler/basicTypes/DataCon.hs +++ b/compiler/basicTypes/DataCon.hs @@ -59,7 +59,7 @@ promoteDataCon ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/Demand.hs b/compiler/basicTypes/Demand.hs --- a/compiler/basicTypes/Demand.hs +++ b/compiler/basicTypes/Demand.hs @@ -60,7 +60,7 @@ ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/Id.hs b/compiler/basicTypes/Id.hs --- a/compiler/basicTypes/Id.hs +++ b/compiler/basicTypes/Id.hs @@ -114,7 +114,7 @@ ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/IdInfo.hs b/compiler/basicTypes/IdInfo.hs --- a/compiler/basicTypes/IdInfo.hs +++ b/compiler/basicTypes/IdInfo.hs @@ -80,7 +80,7 @@ isNeverLevPolyIdInfo ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/Literal.hs b/compiler/basicTypes/Literal.hs --- a/compiler/basicTypes/Literal.hs +++ b/compiler/basicTypes/Literal.hs @@ -47,7 +47,7 @@ , nullAddrLit, rubbishLit, float2DoubleLit, double2FloatLit ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/MkId.hs b/compiler/basicTypes/MkId.hs --- a/compiler/basicTypes/MkId.hs +++ b/compiler/basicTypes/MkId.hs @@ -34,7 +34,7 @@ module PrelRules ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/NameCache.hs b/compiler/basicTypes/NameCache.hs --- a/compiler/basicTypes/NameCache.hs +++ b/compiler/basicTypes/NameCache.hs @@ -20,7 +20,7 @@ import Outputable import PrelNames -#include "GhclibHsVersions.h" +#include "HsVersions.h" {- diff --git a/compiler/basicTypes/NameEnv.hs b/compiler/basicTypes/NameEnv.hs --- a/compiler/basicTypes/NameEnv.hs +++ b/compiler/basicTypes/NameEnv.hs @@ -31,7 +31,7 @@ depAnal ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/NameSet.hs b/compiler/basicTypes/NameSet.hs --- a/compiler/basicTypes/NameSet.hs +++ b/compiler/basicTypes/NameSet.hs @@ -31,7 +31,7 @@ findUses, duDefs, duUses, allUses ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/PatSyn.hs b/compiler/basicTypes/PatSyn.hs --- a/compiler/basicTypes/PatSyn.hs +++ b/compiler/basicTypes/PatSyn.hs @@ -22,7 +22,7 @@ updatePatSynIds, pprPatSynType ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/RdrName.hs b/compiler/basicTypes/RdrName.hs --- a/compiler/basicTypes/RdrName.hs +++ b/compiler/basicTypes/RdrName.hs @@ -68,7 +68,7 @@ starInfo ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/Unique.hs b/compiler/basicTypes/Unique.hs --- a/compiler/basicTypes/Unique.hs +++ b/compiler/basicTypes/Unique.hs @@ -67,7 +67,7 @@ dataConWorkerUnique, dataConTyRepNameUnique ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" #include "Unique.h" import GhcPrelude diff --git a/compiler/basicTypes/Var.hs b/compiler/basicTypes/Var.hs --- a/compiler/basicTypes/Var.hs +++ b/compiler/basicTypes/Var.hs @@ -82,7 +82,7 @@ ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/basicTypes/VarSet.hs b/compiler/basicTypes/VarSet.hs --- a/compiler/basicTypes/VarSet.hs +++ b/compiler/basicTypes/VarSet.hs @@ -43,7 +43,7 @@ dVarSetToVarSet, ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/coreSyn/CoreArity.hs b/compiler/coreSyn/CoreArity.hs --- a/compiler/coreSyn/CoreArity.hs +++ b/compiler/coreSyn/CoreArity.hs @@ -16,7 +16,7 @@ exprBotStrictness_maybe ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/coreSyn/CoreFVs.hs b/compiler/coreSyn/CoreFVs.hs --- a/compiler/coreSyn/CoreFVs.hs +++ b/compiler/coreSyn/CoreFVs.hs @@ -57,7 +57,7 @@ freeVarsOfAnn ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/coreSyn/CoreOpt.hs b/compiler/coreSyn/CoreOpt.hs --- a/compiler/coreSyn/CoreOpt.hs +++ b/compiler/coreSyn/CoreOpt.hs @@ -18,7 +18,7 @@ pushCoArg, pushCoValArg, pushCoTyArg, collectBindersPushingCo ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/coreSyn/CoreSubst.hs b/compiler/coreSyn/CoreSubst.hs --- a/compiler/coreSyn/CoreSubst.hs +++ b/compiler/coreSyn/CoreSubst.hs @@ -33,7 +33,7 @@ ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/coreSyn/CoreSyn.hs b/compiler/coreSyn/CoreSyn.hs --- a/compiler/coreSyn/CoreSyn.hs +++ b/compiler/coreSyn/CoreSyn.hs @@ -95,7 +95,7 @@ isBuiltinRule, isLocalRule, isAutoRule, ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/coreSyn/CoreTidy.hs b/compiler/coreSyn/CoreTidy.hs --- a/compiler/coreSyn/CoreTidy.hs +++ b/compiler/coreSyn/CoreTidy.hs @@ -12,7 +12,7 @@ tidyExpr, tidyRule, tidyRules, tidyUnfolding ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/coreSyn/CoreUnfold.hs b/compiler/coreSyn/CoreUnfold.hs --- a/compiler/coreSyn/CoreUnfold.hs +++ b/compiler/coreSyn/CoreUnfold.hs @@ -40,7 +40,7 @@ exprIsConApp_maybe, exprIsLiteral_maybe ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/coreSyn/CoreUtils.hs b/compiler/coreSyn/CoreUtils.hs --- a/compiler/coreSyn/CoreUtils.hs +++ b/compiler/coreSyn/CoreUtils.hs @@ -57,7 +57,7 @@ isJoinBind ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/coreSyn/MkCore.hs b/compiler/coreSyn/MkCore.hs --- a/compiler/coreSyn/MkCore.hs +++ b/compiler/coreSyn/MkCore.hs @@ -49,7 +49,7 @@ tYPE_ERROR_ID, aBSENT_SUM_FIELD_ERROR_ID ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/deSugar/PmExpr.hs b/compiler/deSugar/PmExpr.hs --- a/compiler/deSugar/PmExpr.hs +++ b/compiler/deSugar/PmExpr.hs @@ -14,7 +14,7 @@ pprPmExprWithParens, runPmPprM ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/hsSyn/HsDoc.hs b/compiler/hsSyn/HsDoc.hs --- a/compiler/hsSyn/HsDoc.hs +++ b/compiler/hsSyn/HsDoc.hs @@ -21,7 +21,7 @@ , emptyArgDocMap ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/hsSyn/HsDumpAst.hs b/compiler/hsSyn/HsDumpAst.hs deleted file mode 100644 --- a/compiler/hsSyn/HsDumpAst.hs +++ /dev/null @@ -1,220 +0,0 @@ -{- -(c) The University of Glasgow 2006 -(c) The GRASP/AQUA Project, Glasgow University, 1992-1998 --} -{-# LANGUAGE RankNTypes #-} -{-# LANGUAGE ScopedTypeVariables #-} - --- | Contains a debug function to dump parts of the hsSyn AST. It uses a syb --- traversal which falls back to displaying based on the constructor name, so --- can be used to dump anything having a @Data.Data@ instance. - -module HsDumpAst ( - -- * Dumping ASTs - showAstData, - BlankSrcSpan(..), - ) where - -import GhcPrelude - -import Data.Data hiding (Fixity) -import Bag -import BasicTypes -import FastString -import NameSet -import Name -import DataCon -import SrcLoc -import HsSyn -import OccName hiding (occName) -import Var -import Module -import Outputable - -import qualified Data.ByteString as B - -data BlankSrcSpan = BlankSrcSpan | NoBlankSrcSpan - deriving (Eq,Show) - --- | Show a GHC syntax tree. This parameterised because it is also used for --- comparing ASTs in ppr roundtripping tests, where the SrcSpan's are blanked --- out, to avoid comparing locations, only structure -showAstData :: Data a => BlankSrcSpan -> a -> SDoc -showAstData b a0 = blankLine $$ showAstData' a0 - where - showAstData' :: Data a => a -> SDoc - showAstData' = - generic - `ext1Q` list - `extQ` string `extQ` fastString `extQ` srcSpan - `extQ` lit `extQ` litr `extQ` litt - `extQ` bytestring - `extQ` name `extQ` occName `extQ` moduleName `extQ` var - `extQ` dataCon - `extQ` bagName `extQ` bagRdrName `extQ` bagVar `extQ` nameSet - `extQ` fixity - `ext2Q` located - - where generic :: Data a => a -> SDoc - generic t = parens $ text (showConstr (toConstr t)) - $$ vcat (gmapQ showAstData' t) - - string :: String -> SDoc - string = text . normalize_newlines . show - - fastString :: FastString -> SDoc - fastString s = braces $ - text "FastString: " - <> text (normalize_newlines . show $ s) - - bytestring :: B.ByteString -> SDoc - bytestring = text . normalize_newlines . show - - list [] = brackets empty - list [x] = brackets (showAstData' x) - list (x1 : x2 : xs) = (text "[" <> showAstData' x1) - $$ go x2 xs - where - go y [] = text "," <> showAstData' y <> text "]" - go y1 (y2 : ys) = (text "," <> showAstData' y1) $$ go y2 ys - - -- Eliminate word-size dependence - lit :: HsLit GhcPs -> SDoc - lit (HsWordPrim s x) = numericLit "HsWord{64}Prim" x s - lit (HsWord64Prim s x) = numericLit "HsWord{64}Prim" x s - lit (HsIntPrim s x) = numericLit "HsInt{64}Prim" x s - lit (HsInt64Prim s x) = numericLit "HsInt{64}Prim" x s - lit l = generic l - - litr :: HsLit GhcRn -> SDoc - litr (HsWordPrim s x) = numericLit "HsWord{64}Prim" x s - litr (HsWord64Prim s x) = numericLit "HsWord{64}Prim" x s - litr (HsIntPrim s x) = numericLit "HsInt{64}Prim" x s - litr (HsInt64Prim s x) = numericLit "HsInt{64}Prim" x s - litr l = generic l - - litt :: HsLit GhcTc -> SDoc - litt (HsWordPrim s x) = numericLit "HsWord{64}Prim" x s - litt (HsWord64Prim s x) = numericLit "HsWord{64}Prim" x s - litt (HsIntPrim s x) = numericLit "HsInt{64}Prim" x s - litt (HsInt64Prim s x) = numericLit "HsInt{64}Prim" x s - litt l = generic l - - numericLit :: String -> Integer -> SourceText -> SDoc - numericLit tag x s = braces $ hsep [ text tag - , generic x - , generic s ] - - name :: Name -> SDoc - name nm = braces $ text "Name: " <> ppr nm - - occName n = braces $ - text "OccName: " - <> text (OccName.occNameString n) - - moduleName :: ModuleName -> SDoc - moduleName m = braces $ text "ModuleName: " <> ppr m - - srcSpan :: SrcSpan -> SDoc - srcSpan ss = case b of - BlankSrcSpan -> text "{ ss }" - NoBlankSrcSpan -> braces $ char ' ' <> - (hang (ppr ss) 1 - -- TODO: show annotations here - (text "")) - - var :: Var -> SDoc - var v = braces $ text "Var: " <> ppr v - - dataCon :: DataCon -> SDoc - dataCon c = braces $ text "DataCon: " <> ppr c - - bagRdrName:: Bag (Located (HsBind GhcPs)) -> SDoc - bagRdrName bg = braces $ - text "Bag(Located (HsBind GhcPs)):" - $$ (list . bagToList $ bg) - - bagName :: Bag (Located (HsBind GhcRn)) -> SDoc - bagName bg = braces $ - text "Bag(Located (HsBind Name)):" - $$ (list . bagToList $ bg) - - bagVar :: Bag (Located (HsBind GhcTc)) -> SDoc - bagVar bg = braces $ - text "Bag(Located (HsBind Var)):" - $$ (list . bagToList $ bg) - - nameSet ns = braces $ - text "NameSet:" - $$ (list . nameSetElemsStable $ ns) - - fixity :: Fixity -> SDoc - fixity fx = braces $ - text "Fixity: " - <> ppr fx - - located :: (Data b,Data loc) => GenLocated loc b -> SDoc - located (L ss a) = parens $ - case cast ss of - Just (s :: SrcSpan) -> - srcSpan s - Nothing -> text "nnnnnnnn" - $$ showAstData' a - -normalize_newlines :: String -> String -normalize_newlines ('\\':'r':'\\':'n':xs) = '\\':'n':normalize_newlines xs -normalize_newlines (x:xs) = x:normalize_newlines xs -normalize_newlines [] = [] - -{- -************************************************************************ -* * -* Copied from syb -* * -************************************************************************ --} - - --- | The type constructor for queries -newtype Q q x = Q { unQ :: x -> q } - --- | Extend a generic query by a type-specific case -extQ :: ( Typeable a - , Typeable b - ) - => (a -> q) - -> (b -> q) - -> a - -> q -extQ f g a = maybe (f a) g (cast a) - --- | Type extension of queries for type constructors -ext1Q :: (Data d, Typeable t) - => (d -> q) - -> (forall e. Data e => t e -> q) - -> d -> q -ext1Q def ext = unQ ((Q def) `ext1` (Q ext)) - - --- | Type extension of queries for type constructors -ext2Q :: (Data d, Typeable t) - => (d -> q) - -> (forall d1 d2. (Data d1, Data d2) => t d1 d2 -> q) - -> d -> q -ext2Q def ext = unQ ((Q def) `ext2` (Q ext)) - --- | Flexible type extension -ext1 :: (Data a, Typeable t) - => c a - -> (forall d. Data d => c (t d)) - -> c a -ext1 def ext = maybe def id (dataCast1 ext) - - - --- | Flexible type extension -ext2 :: (Data a, Typeable t) - => c a - -> (forall d1 d2. (Data d1, Data d2) => c (t d1 d2)) - -> c a -ext2 def ext = maybe def id (dataCast2 ext) diff --git a/compiler/hsSyn/HsExpr.hs b/compiler/hsSyn/HsExpr.hs --- a/compiler/hsSyn/HsExpr.hs +++ b/compiler/hsSyn/HsExpr.hs @@ -16,7 +16,7 @@ -- | Abstract Haskell syntax for expressions. module HsExpr where -#include "GhclibHsVersions.h" +#include "HsVersions.h" -- friends: import GhcPrelude diff --git a/compiler/hsSyn/HsLit.hs b/compiler/hsSyn/HsLit.hs --- a/compiler/hsSyn/HsLit.hs +++ b/compiler/hsSyn/HsLit.hs @@ -16,7 +16,7 @@ module HsLit where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/hsSyn/HsUtils.hs b/compiler/hsSyn/HsUtils.hs --- a/compiler/hsSyn/HsUtils.hs +++ b/compiler/hsSyn/HsUtils.hs @@ -57,7 +57,7 @@ -- Types mkHsAppTy, mkHsAppKindTy, userHsTyVarBndrs, userHsLTyVarBndrs, mkLHsSigType, mkLHsSigWcType, mkClassOpSigs, mkHsSigEnv, - nlHsAppTy, nlHsTyVar, nlHsFunTy, nlHsParTy, nlHsTyConApp, + nlHsAppTy, nlHsAppKindTy, nlHsTyVar, nlHsFunTy, nlHsParTy, nlHsTyConApp, -- Stmts mkTransformStmt, mkTransformByStmt, mkBodyStmt, mkBindStmt, mkTcBindStmt, @@ -88,7 +88,7 @@ lStmtsImplicits, hsValBindsImplicits, lPatImplicits ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude @@ -105,14 +105,14 @@ import RdrName import Var import TyCoRep -import Type ( filterOutInvisibleTypes ) +import Type ( tyConArgFlags ) import TysWiredIn ( unitTy ) import TcType import DataCon import ConLike import Id import Name -import NameSet +import NameSet hiding ( unitFV ) import NameEnv import BasicTypes import SrcLoc @@ -121,7 +121,6 @@ import Bag import Outputable import Constants -import TyCon import Data.Either import Data.Function @@ -510,6 +509,10 @@ nlHsTyConApp :: IdP (GhcPass p) -> [LHsType (GhcPass p)] -> LHsType (GhcPass p) nlHsTyConApp tycon tys = foldl' nlHsAppTy (nlHsTyVar tycon) tys +nlHsAppKindTy :: + LHsType (GhcPass p) -> LHsKind (GhcPass p) -> LHsType (GhcPass p) +nlHsAppKindTy f k = noLoc (HsAppKindTy noSrcSpan f (parenthesizeHsType appPrec k)) + {- Tuples. All these functions are *pre-typechecker* because they lack types on the tuple. @@ -669,14 +672,24 @@ go (LitTy (StrTyLit s)) = noLoc $ HsTyLit NoExt (HsStrTy NoSourceText s) go ty@(TyConApp tc args) - | any isInvisibleTyConBinder (tyConBinders tc) + | tyConAppNeedsKindSig True tc (length args) -- We must produce an explicit kind signature here to make certain -- programs kind-check. See Note [Kind signatures in typeToLHsType]. = nlHsParTy $ noLoc $ HsKindSig NoExt lhs_ty (go (typeKind ty)) | otherwise = lhs_ty where - lhs_ty = nlHsTyConApp (getRdrName tc) (map go args') - args' = filterOutInvisibleTypes tc args + arg_flags :: [ArgFlag] + arg_flags = tyConArgFlags tc args + + lhs_ty :: LHsType GhcPs + lhs_ty = foldl' (\f (arg, flag) -> + let arg' = go arg in + case flag of + Inferred -> f + Specified -> f `nlHsAppKindTy` arg' + Required -> f `nlHsAppTy` arg') + (nlHsTyVar (getRdrName tc)) + (zip args arg_flags) go (CastTy ty _) = go ty go (CoercionTy co) = pprPanic "toLHsSigWcType" (ppr co) @@ -693,48 +706,40 @@ There are types that typeToLHsType can produce which require explicit kind signatures in order to kind-check. Here is an example from Trac #14579: - newtype Wat (x :: Proxy (a :: Type)) = MkWat (Maybe a) deriving Eq - newtype Glurp a = MkGlurp (Wat ('Proxy :: Proxy a)) deriving Eq + -- type P :: forall {k} {t :: k}. Proxy t + type P = 'Proxy + -- type Wat :: forall a. Proxy a -> * + newtype Wat (x :: Proxy (a :: Type)) = MkWat (Maybe a) + deriving Eq + + -- type Wat2 :: forall {a}. Proxy a -> * + type Wat2 = Wat + + -- type Glurp :: * -> * + newtype Glurp a = MkGlurp (Wat2 (P :: Proxy a)) + deriving Eq + The derived Eq instance for Glurp (without any kind signatures) would be: instance Eq a => Eq (Glurp a) where - (==) = coerce @(Wat 'Proxy -> Wat 'Proxy -> Bool) - @(Glurp a -> Glurp a -> Bool) + (==) = coerce @(Wat2 P -> Wat2 P -> Bool) + @(Glurp a -> Glurp a -> Bool) (==) :: Glurp a -> Glurp a -> Bool (Where the visible type applications use types produced by typeToLHsType.) -The type 'Proxy has an underspecified kind, so we must ensure that -typeToLHsType ascribes it with its kind: ('Proxy :: Proxy a). - -We must be careful not to produce too many kind signatures, or else -typeToLHsType can produce noisy types like -('Proxy :: Proxy (a :: (Type :: Type))). In pursuit of this goal, we adopt the -following criterion for choosing when to annotate types with kinds: - -* If there is a tycon application with any invisible arguments, annotate - the tycon application with its kind. - -Why is this the right criterion? The problem we encountered earlier was the -result of an invisible argument (the `a` in ('Proxy :: Proxy a)) being -underspecified, so producing a kind signature for 'Proxy will catch this. -If there are no invisible arguments, then there is nothing to do, so we can -avoid polluting the result type with redundant noise. - -What about a more complicated tycon, such as this? - - T :: forall {j} (a :: j). a -> Type - -Unlike in the previous 'Proxy example, annotating an application of `T` to an -argument (e.g., annotating T ty to obtain (T ty :: Type)) will not fix -its invisible argument `j`. But because we apply this strategy recursively, -`j` will be fixed because the kind of `ty` will be fixed! That is to say, -something to the effect of (T (ty :: j) :: Type) will be produced. +The type P (in Wat2 P) has an underspecified kind, so we must ensure that +typeToLHsType ascribes it with its kind: Wat2 (P :: Proxy a). To accomplish +this, whenever we see an application of a tycon to some arguments, we use +the tyConAppNeedsKindSig function to determine if it requires an explicit kind +signature to resolve some ambiguity. (See Note +Note [When does a tycon application need an explicit kind signature?] for a +more detailed explanation of how this works.) -This strategy certainly isn't foolproof, as tycons that contain type families -in their kind might break down. But we'd likely need visible kind application -to make those work. +Note that we pass True to tyConAppNeedsKindSig since we are generated code with +visible kind applications, so even specified arguments count towards injective +positions in the kind of the tycon. -} {- ********************************************************************* diff --git a/compiler/iface/BinFingerprint.hs b/compiler/iface/BinFingerprint.hs --- a/compiler/iface/BinFingerprint.hs +++ b/compiler/iface/BinFingerprint.hs @@ -8,7 +8,7 @@ , putNameLiterally ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/iface/IfaceSyn.hs b/compiler/iface/IfaceSyn.hs --- a/compiler/iface/IfaceSyn.hs +++ b/compiler/iface/IfaceSyn.hs @@ -39,7 +39,7 @@ AltPpr(..), ShowSub(..), ShowHowMuch(..), showToIface, showToHeader ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude @@ -1114,7 +1114,7 @@ -- [VarBndrs, TyCoVarBinders, TyConBinders, and visibility] in TyCoRep.) ppr_tc_app gadt_subst = pprPrefixIfDeclBndr how_much (occName tycon) - <+> pprIfaceAppArgs + <+> pprParendIfaceAppArgs (substIfaceAppArgs gadt_subst (mk_tc_app_args tc_binders)) mk_tc_app_args :: [IfaceTyConBinder] -> IfaceAppArgs diff --git a/compiler/iface/IfaceType.hs b/compiler/iface/IfaceType.hs --- a/compiler/iface/IfaceType.hs +++ b/compiler/iface/IfaceType.hs @@ -51,7 +51,7 @@ mkIfaceTySubst, substIfaceTyVar, substIfaceAppArgs, inDomIfaceTySubst ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/iface/ToIface.hs b/compiler/iface/ToIface.hs --- a/compiler/iface/ToIface.hs +++ b/compiler/iface/ToIface.hs @@ -42,7 +42,7 @@ , toIfaceVar ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/main/CmdLineParser.hs b/compiler/main/CmdLineParser.hs --- a/compiler/main/CmdLineParser.hs +++ b/compiler/main/CmdLineParser.hs @@ -23,7 +23,7 @@ deprecate ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/main/DriverPhases.hs b/compiler/main/DriverPhases.hs --- a/compiler/main/DriverPhases.hs +++ b/compiler/main/DriverPhases.hs @@ -38,7 +38,7 @@ isSourceFilename ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/main/DynFlags.hs b/compiler/main/DynFlags.hs --- a/compiler/main/DynFlags.hs +++ b/compiler/main/DynFlags.hs @@ -181,7 +181,7 @@ CfgWeights(..), backendMaintainsCfg ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/main/ErrUtils.hs b/compiler/main/ErrUtils.hs --- a/compiler/main/ErrUtils.hs +++ b/compiler/main/ErrUtils.hs @@ -56,7 +56,7 @@ traceCmd ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/main/HeaderInfo.hs b/compiler/main/HeaderInfo.hs --- a/compiler/main/HeaderInfo.hs +++ b/compiler/main/HeaderInfo.hs @@ -18,7 +18,7 @@ , optionsErrorMsgs, checkProcessArgsResult ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/main/HscTypes.hs b/compiler/main/HscTypes.hs --- a/compiler/main/HscTypes.hs +++ b/compiler/main/HscTypes.hs @@ -141,7 +141,7 @@ mkCompleteMatchMap, extendCompleteMatchMap ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/main/PackageConfig.hs b/compiler/main/PackageConfig.hs --- a/compiler/main/PackageConfig.hs +++ b/compiler/main/PackageConfig.hs @@ -28,7 +28,7 @@ pprPackageConfig, ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/main/Packages.hs b/compiler/main/Packages.hs --- a/compiler/main/Packages.hs +++ b/compiler/main/Packages.hs @@ -63,7 +63,7 @@ ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/main/SysTools/BaseDir.hs b/compiler/main/SysTools/BaseDir.hs --- a/compiler/main/SysTools/BaseDir.hs +++ b/compiler/main/SysTools/BaseDir.hs @@ -16,7 +16,7 @@ , findTopDir, findToolDir ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/parser/Ctype.hs b/compiler/parser/Ctype.hs --- a/compiler/parser/Ctype.hs +++ b/compiler/parser/Ctype.hs @@ -14,7 +14,7 @@ , hexDigit, octDecDigit ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/parser/RdrHsSyn.hs b/compiler/parser/RdrHsSyn.hs --- a/compiler/parser/RdrHsSyn.hs +++ b/compiler/parser/RdrHsSyn.hs @@ -121,7 +121,7 @@ import qualified Data.Monoid as Monoid import Data.Data ( dataTypeOf, fromConstr, dataTypeConstrs ) -#include "GhclibHsVersions.h" +#include "HsVersions.h" {- ********************************************************************** diff --git a/compiler/prelude/KnownUniques.hs b/compiler/prelude/KnownUniques.hs --- a/compiler/prelude/KnownUniques.hs +++ b/compiler/prelude/KnownUniques.hs @@ -24,7 +24,7 @@ , mkCTupleDataConUnique ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/prelude/PrelNames.hs b/compiler/prelude/PrelNames.hs --- a/compiler/prelude/PrelNames.hs +++ b/compiler/prelude/PrelNames.hs @@ -155,7 +155,7 @@ -- So many that we export them all ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/prelude/PrelRules.hs b/compiler/prelude/PrelRules.hs --- a/compiler/prelude/PrelRules.hs +++ b/compiler/prelude/PrelRules.hs @@ -22,7 +22,7 @@ ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" #include "../includes/MachDeps.h" import GhcPrelude diff --git a/compiler/prelude/PrimOp.hs b/compiler/prelude/PrimOp.hs --- a/compiler/prelude/PrimOp.hs +++ b/compiler/prelude/PrimOp.hs @@ -26,7 +26,7 @@ PrimCall(..) ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/prelude/TysPrim.hs b/compiler/prelude/TysPrim.hs --- a/compiler/prelude/TysPrim.hs +++ b/compiler/prelude/TysPrim.hs @@ -86,7 +86,7 @@ #include "primop-vector-tys-exports.hs-incl" ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/prelude/TysWiredIn.hs b/compiler/prelude/TysWiredIn.hs --- a/compiler/prelude/TysWiredIn.hs +++ b/compiler/prelude/TysWiredIn.hs @@ -123,7 +123,7 @@ ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" #include "MachDeps.h" import GhcPrelude diff --git a/compiler/simplCore/OccurAnal.hs b/compiler/simplCore/OccurAnal.hs --- a/compiler/simplCore/OccurAnal.hs +++ b/compiler/simplCore/OccurAnal.hs @@ -17,7 +17,7 @@ occurAnalysePgm, occurAnalyseExpr, occurAnalyseExpr_NoBinderSwap ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude @@ -2373,9 +2373,14 @@ _ -> (env { occ_encl = OccVanilla }, Nothing) where - add_scrut v rhs = ( env { occ_encl = OccVanilla - , occ_gbl_scrut = pe `extendVarSet` v } - , Just (localise v, rhs) ) + add_scrut v rhs + | isGlobalId v = (env { occ_encl = OccVanilla }, Nothing) + | otherwise = ( env { occ_encl = OccVanilla + , occ_gbl_scrut = pe `extendVarSet` v } + , Just (localise v, rhs) ) + -- ToDO: this isGlobalId stuff is a TEMPORARY FIX + -- to avoid the binder-swap for GlobalIds + -- See Trac #16346 case_bndr' = Var (zapIdOccInfo case_bndr) -- See Note [Zap case binders in proxy bindings] diff --git a/compiler/simplStg/RepType.hs b/compiler/simplStg/RepType.hs --- a/compiler/simplStg/RepType.hs +++ b/compiler/simplStg/RepType.hs @@ -21,7 +21,7 @@ slotPrimRep, primRepSlot ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/specialise/Rules.hs b/compiler/specialise/Rules.hs --- a/compiler/specialise/Rules.hs +++ b/compiler/specialise/Rules.hs @@ -26,7 +26,7 @@ lookupRule, mkRule, roughTopNames ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/typecheck/TcEvidence.hs b/compiler/typecheck/TcEvidence.hs --- a/compiler/typecheck/TcEvidence.hs +++ b/compiler/typecheck/TcEvidence.hs @@ -45,7 +45,7 @@ tcCoercionRole, unwrapIP, wrapIP ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/typecheck/TcRnTypes.hs b/compiler/typecheck/TcRnTypes.hs --- a/compiler/typecheck/TcRnTypes.hs +++ b/compiler/typecheck/TcRnTypes.hs @@ -145,7 +145,7 @@ ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/typecheck/TcType.hs b/compiler/typecheck/TcType.hs --- a/compiler/typecheck/TcType.hs +++ b/compiler/typecheck/TcType.hs @@ -188,7 +188,7 @@ ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" -- friends: import GhcPrelude diff --git a/compiler/types/Class.hs b/compiler/types/Class.hs --- a/compiler/types/Class.hs +++ b/compiler/types/Class.hs @@ -21,7 +21,7 @@ isAbstractClass, ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/types/CoAxiom.hs b/compiler/types/CoAxiom.hs --- a/compiler/types/CoAxiom.hs +++ b/compiler/types/CoAxiom.hs @@ -48,7 +48,7 @@ import Data.Array import Data.List ( mapAccumL ) -#include "GhclibHsVersions.h" +#include "HsVersions.h" {- Note [Coercion axiom branches] diff --git a/compiler/types/Coercion.hs b/compiler/types/Coercion.hs --- a/compiler/types/Coercion.hs +++ b/compiler/types/Coercion.hs @@ -112,7 +112,7 @@ simplifyArgsWorker ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import {-# SOURCE #-} ToIface (toIfaceTyCon, tidyToIfaceTcArgs) diff --git a/compiler/types/FamInstEnv.hs b/compiler/types/FamInstEnv.hs --- a/compiler/types/FamInstEnv.hs +++ b/compiler/types/FamInstEnv.hs @@ -36,7 +36,7 @@ flattenTys ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/types/InstEnv.hs b/compiler/types/InstEnv.hs --- a/compiler/types/InstEnv.hs +++ b/compiler/types/InstEnv.hs @@ -29,7 +29,7 @@ isOverlappable, isOverlapping, isIncoherent ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/types/Kind.hs b/compiler/types/Kind.hs --- a/compiler/types/Kind.hs +++ b/compiler/types/Kind.hs @@ -13,7 +13,7 @@ isKindLevPoly ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/types/OptCoercion.hs b/compiler/types/OptCoercion.hs --- a/compiler/types/OptCoercion.hs +++ b/compiler/types/OptCoercion.hs @@ -8,7 +8,7 @@ module OptCoercion ( optCoercion, checkAxInstCo ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/types/TyCoRep.hs b/compiler/types/TyCoRep.hs --- a/compiler/types/TyCoRep.hs +++ b/compiler/types/TyCoRep.hs @@ -90,7 +90,7 @@ tyCoFVsOfCo, tyCoFVsOfCos, tyCoVarsOfCoList, tyCoVarsOfProv, almostDevoidCoVarOfCo, - injectiveVarsOfBinder, injectiveVarsOfType, + injectiveVarsOfType, tyConAppNeedsKindSig, noFreeVarsOfType, noFreeVarsOfCo, @@ -149,7 +149,7 @@ typeSize, coercionSize, provSize ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude @@ -2100,20 +2100,21 @@ ------------- Injective free vars ----------------- --- | Returns the free variables of a 'TyConBinder' that are in injective --- positions. (See @Note [Kind annotations on TyConApps]@ in "TcSplice" for an --- explanation of what an injective position is.) -injectiveVarsOfBinder :: TyConBinder -> FV -injectiveVarsOfBinder (Bndr tv vis) = - case vis of - AnonTCB -> injectiveVarsOfType (varType tv) - NamedTCB Required -> unitFV tv `unionFV` - injectiveVarsOfType (varType tv) - NamedTCB _ -> emptyFV - -- | Returns the free variables of a 'Type' that are in injective positions. --- (See @Note [Kind annotations on TyConApps]@ in "TcSplice" for an explanation --- of what an injective position is.) +-- For example, if @F@ is a non-injective type family, then: +-- +-- @ +-- injectiveTyVarsOf( Either c (Maybe (a, F b c)) ) = {a,c} +-- @ +-- +-- If @'injectiveVarsOfType' ty = itvs@, then knowing @ty@ fixes @itvs@. +-- More formally, if +-- @a@ is in @'injectiveVarsOfType' ty@ +-- and @S1(ty) ~ S2(ty)@, +-- then @S1(a) ~ S2(a)@, +-- where @S1@ and @S2@ are arbitrary substitutions. +-- +-- See @Note [When does a tycon application need an explicit kind signature?]@. injectiveVarsOfType :: Type -> FV injectiveVarsOfType = go where @@ -2129,11 +2130,283 @@ filterByList (inj ++ repeat True) tys -- Oversaturated arguments to a tycon are -- always injective, hence the repeat True - go (ForAllTy tvb ty) = tyCoFVsBndr tvb $ go (binderType tvb) - `unionFV` go ty + go (ForAllTy tvb ty) = tyCoFVsBndr tvb $ go ty go LitTy{} = emptyFV go (CastTy ty _) = go ty go CoercionTy{} = emptyFV + +-- | Does a 'TyCon' (that is applied to some number of arguments) need to be +-- ascribed with an explicit kind signature to resolve ambiguity if rendered as +-- a source-syntax type? +-- (See @Note [When does a tycon application need an explicit kind signature?]@ +-- for a full explanation of what this function checks for.) + +-- Morally, this function ought to belong in TyCon.hs, not TyCoRep.hs, but +-- accomplishing this requires a fair deal of futzing aruond with .hs-boot +-- files. +tyConAppNeedsKindSig + :: Bool -- ^ Should specified binders count towards injective positions in + -- the kind of the TyCon? + -> TyCon + -> Int -- ^ The number of args the 'TyCon' is applied to. + -> Bool -- ^ Does @T t_1 ... t_n@ need a kind signature? (Where @n@ is the + -- number of arguments) +tyConAppNeedsKindSig spec_inj_pos tc n_args + | LT <- listLengthCmp tc_binders n_args + = False + | otherwise + = let (dropped_binders, remaining_binders) + = splitAt n_args tc_binders + result_kind = mkTyConKind remaining_binders tc_res_kind + result_vars = tyCoVarsOfType result_kind + dropped_vars = fvVarSet $ + mapUnionFV (injective_vars_of_binder spec_inj_pos) + dropped_binders + + in not (subVarSet result_vars dropped_vars) + where + tc_binders = tyConBinders tc + tc_res_kind = tyConResKind tc + + -- Returns the variables that would be fixed by knowing a TyConBinder. See + -- Note [When does a tycon application need an explicit kind signature?] + -- for a more detailed explanation of what this function does. + injective_vars_of_binder + :: Bool -- Should specified binders count towards injective positions? + -- (If you're using visible kind applications, then you want True + -- here.) + -> TyConBinder -> FV + injective_vars_of_binder spec_inj_pos (Bndr tv vis) = + case vis of + AnonTCB -> injectiveVarsOfType (varType tv) + NamedTCB argf + | (argf == Required) + || (spec_inj_pos && (argf == Specified)) + -> unitFV tv `unionFV` injectiveVarsOfType (varType tv) + | otherwise + -> emptyFV + +{- +Note [When does a tycon application need an explicit kind signature?] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +There are a couple of places in GHC where we convert Core Types into forms that +more closely resemble user-written syntax. These include: + +1. Template Haskell Type reification (see, for instance, TcSplice.reify_tc_app) +2. Converting Types to LHsTypes (in HsUtils.typeToLHsType, or in Haddock) + +This conversion presents a challenge: how do we ensure that the resulting type +has enough kind information so as not to be ambiguous? To better motivate this +question, consider the following Core type: + + -- Foo :: Type -> Type + type Foo = Proxy Type + +There is nothing ambiguous about the RHS of Foo in Core. But if we were to, +say, reify it into a TH Type, then it's tempting to just drop the invisible +Type argument and simply return `Proxy`. But now we've lost crucial kind +information: we don't know if we're dealing with `Proxy Type` or `Proxy Bool` +or `Proxy Int` or something else! We've inadvertently introduced ambiguity. + +Unlike in other situations in GHC, we can't just turn on +-fprint-explicit-kinds, as we need to produce something which has the same +structure as a source-syntax type. Moreover, we can't rely on visible kind +application, since the first kind argument to Proxy is inferred, not specified. +Our solution is to annotate certain tycons with their kinds whenever they +appear in applied form in order to resolve the ambiguity. For instance, we +would reify the RHS of Foo like so: + + type Foo = (Proxy :: Type -> Type) + +We need to devise an algorithm that determines precisely which tycons need +these explicit kind signatures. We certainly don't want to annotate _every_ +tycon with a kind signature, or else we might end up with horribly bloated +types like the following: + + (Either :: Type -> Type -> Type) (Int :: Type) (Char :: Type) + +We only want to annotate tycons that absolutely require kind signatures in +order to resolve some sort of ambiguity, and nothing more. + +Suppose we have a tycon application (T ty_1 ... ty_n). Why might this type +require a kind signature? It might require it when we need to fill in any of +T's omitted arguments. By "omitted argument", we mean one that is dropped when +reifying ty_1 ... ty_n. Sometimes, the omitted arguments are inferred and +specified arguments (e.g., TH reification in TcSplice), and sometimes the +omitted arguments are only the inferred ones (e.g., in HsUtils.typeToLHsType, +which reifies specified arguments through visible kind application). +Regardless, the key idea is that _some_ arguments are going to be omitted after +reification, and the only mechanism we have at our disposal for filling them in +is through explicit kind signatures. + +What do we mean by "fill in"? Let's consider this small example: + + T :: forall {k}. Type -> (k -> Type) -> k + +Moreover, we have this application of T: + + T @{j} Int aty + +When we reify this type, we omit the inferred argument @{j}. Is it fixed by the +other (non-inferred) arguments? Yes! If we know the kind of (aty :: blah), then +we'll generate an equality constraint (kappa -> Type) and, assuming we can +solve it, that will fix `kappa`. (Here, `kappa` is the unification variable +that we instantiate `k` with.) + +Therefore, for any application of a tycon T to some arguments, the Question We +Must Answer is: + +* Given the first n arguments of T, do the kinds of the non-omitted arguments + fill in the omitted arguments? + +(This is still a bit hand-wavey, but we'll refine this question incrementally +as we explain more of the machinery underlying this process.) + +Answering this question is precisely the role that the `injectiveVarsOfType` +and `injective_vars_of_binder` functions exist to serve. If an omitted argument +`a` appears in the set returned by `injectiveVarsOfType ty`, then knowing +`ty` determines (i.e., fills in) `a`. (More on `injective_vars_of_binder` in a +bit.) + +More formally, if +`a` is in `injectiveVarsOfType ty` +and S1(ty) ~ S2(ty), +then S1(a) ~ S2(a), +where S1 and S2 are arbitrary substitutions. + +For example, is `F` is a non-injective type family, then + + injectiveVarsOfType(Either c (Maybe (a, F b c))) = {a, c} + +Now that we know what this function does, here is a second attempt at the +Question We Must Answer: + +* Given the first n arguments of T (ty_1 ... ty_n), consider the binders + of T that are instantiated by non-omitted arguments. Do the injective + variables of these binders fill in the remainder of T's kind? + +Alright, we're getting closer. Next, we need to clarify what the injective +variables of a tycon binder are. This the role that the +`injective_vars_of_binder` function serves. Here is what this function does for +each form of tycon binder: + +* Anonymous binders are injective positions. For example, in the promoted data + constructor '(:): + + '(:) :: forall a. a -> [a] -> [a] + + The second and third tyvar binders (of kinds `a` and `[a]`) are both + anonymous, so if we had '(:) 'True '[], then the kinds of 'True and + '[] would contribute to the kind of '(:) 'True '[]. Therefore, + injective_vars_of_binder(_ :: a) = injectiveVarsOfType(a) = {a}. + (Similarly, injective_vars_of_binder(_ :: [a]) = {a}.) +* Named binders: + - Inferred binders are never injective positions. For example, in this data + type: + + data Proxy a + Proxy :: forall {k}. k -> Type + + If we had Proxy 'True, then the kind of 'True would not contribute to the + kind of Proxy 'True. Therefore, + injective_vars_of_binder(forall {k}. ...) = {}. + - Required binders are injective positions. For example, in this data type: + + data Wurble k (a :: k) :: k + Wurble :: forall k -> k -> k + + The first tyvar binder (of kind `forall k`) has required visibility, so if + we had Wurble (Maybe a) Nothing, then the kind of Maybe a would + contribute to the kind of Wurble (Maybe a) Nothing. Hence, + injective_vars_of_binder(forall a -> ...) = {a}. + - Specified binders /might/ be injective positions, depending on how you + approach things. Continuing the '(:) example: + + '(:) :: forall a. a -> [a] -> [a] + + Normally, the (forall a. ...) tyvar binder wouldn't contribute to the kind + of '(:) 'True '[], since it's not explicitly instantiated by the user. But + if visible kind application is enabled, then this is possible, since the + user can write '(:) @Bool 'True '[]. (In that case, + injective_vars_of_binder(forall a. ...) = {a}.) + + There are some situations where using visible kind application is appropriate + (e.g., HsUtils.typeToLHsType) and others where it is not (e.g., TH + reification), so the `injective_vars_of_binder` function is parametrized by + a Bool which decides if specified binders should be counted towards + injective positions or not. + +Now that we've defined injective_vars_of_binder, we can refine the Question We +Must Answer once more: + +* Given the first n arguments of T (ty_1 ... ty_n), consider the binders + of T that are instantiated by non-omitted arguments. For each such binder + b_i, take the union of all injective_vars_of_binder(b_i). Is this set a + superset of the free variables of the remainder of T's kind? + +If the answer to this question is "no", then (T ty_1 ... ty_n) needs an +explicit kind signature, since T's kind has kind variables leftover that +aren't fixed by the non-omitted arguments. + +One last sticking point: what does "the remainder of T's kind" mean? You might +be tempted to think that it corresponds to all of the arguments in the kind of +T that would normally be instantiated by omitted arguments. But this isn't +quite right, strictly speaking. Consider the following (silly) example: + + S :: forall {k}. Type -> Type + +And suppose we have this application of S: + + S Int Bool + +The Int argument would be omitted, and +injective_vars_of_binder(_ :: Type) = {}. This is not a superset of {k}, which +might suggest that (S Bool) needs an explicit kind signature. But +(S Bool :: Type) doesn't actually fix `k`! This is because the kind signature +only affects the /result/ of the application, not all of the individual +arguments. So adding a kind signature here won't make a difference. Therefore, +the fourth (and final) iteration of the Question We Must Answer is: + +* Given the first n arguments of T (ty_1 ... ty_n), consider the binders + of T that are instantiated by non-omitted arguments. For each such binder + b_i, take the union of all injective_vars_of_binder(b_i). Is this set a + superset of the free variables of the kind of (T ty_1 ... ty_n)? + +Phew, that was a lot of work! + +How can be sure that this is correct? That is, how can we be sure that in the +event that we leave off a kind annotation, that one could infer the kind of the +tycon application from its arguments? It's essentially a proof by induction: if +we can infer the kinds of every subtree of a type, then the whole tycon +application will have an inferrable kind--unless, of course, the remainder of +the tycon application's kind has uninstantiated kind variables. + +What happens if T is oversaturated? That is, if T's kind has fewer than n +arguments, in the case that the concrete application instantiates a result +kind variable with an arrow kind? If we run out of arguments, we do not attach +a kind annotation. This should be a rare case, indeed. Here is an example: + + data T1 :: k1 -> k2 -> * + data T2 :: k1 -> k2 -> * + + type family G (a :: k) :: k + type instance G T1 = T2 + + type instance F Char = (G T1 Bool :: (* -> *) -> *) -- F from above + +Here G's kind is (forall k. k -> k), and the desugared RHS of that last +instance of F is (G (* -> (* -> *) -> *) (T1 * (* -> *)) Bool). According to +the algorithm above, there are 3 arguments to G so we should peel off 3 +arguments in G's kind. But G's kind has only two arguments. This is the +rare special case, and we choose not to annotate the application of G with +a kind signature. After all, we needn't do this, since that instance would +be reified as: + + type instance F Char = G (T1 :: * -> (* -> *) -> *) Bool + +So the kind of G isn't ambiguous anymore due to the explicit kind annotation +on its argument. See #8953 and test th/T8953. +-} ------------- No free vars ----------------- diff --git a/compiler/types/TyCon.hs b/compiler/types/TyCon.hs --- a/compiler/types/TyCon.hs +++ b/compiler/types/TyCon.hs @@ -128,7 +128,7 @@ ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/types/Type.hs b/compiler/types/Type.hs --- a/compiler/types/Type.hs +++ b/compiler/types/Type.hs @@ -224,7 +224,7 @@ tidyTyCoVarBinder, tidyTyCoVarBinders ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude @@ -1686,7 +1686,6 @@ tyCoBinderVar_maybe _ = Nothing tyCoBinderType :: TyCoBinder -> Type --- Barely used tyCoBinderType (Named tvb) = binderType tvb tyCoBinderType (Anon ty) = ty diff --git a/compiler/types/Unify.hs b/compiler/types/Unify.hs --- a/compiler/types/Unify.hs +++ b/compiler/types/Unify.hs @@ -24,7 +24,7 @@ liftCoMatch ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/utils/Binary.hs b/compiler/utils/Binary.hs --- a/compiler/utils/Binary.hs +++ b/compiler/utils/Binary.hs @@ -55,7 +55,7 @@ putDictionary, getDictionary, putFS, ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" -- The *host* architecture version: #include "../includes/MachDeps.h" diff --git a/compiler/utils/Digraph.hs b/compiler/utils/Digraph.hs --- a/compiler/utils/Digraph.hs +++ b/compiler/utils/Digraph.hs @@ -25,7 +25,7 @@ EdgeType(..), classifyEdges ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" ------------------------------------------------------------------------------ -- A version of the graph algorithms described in: diff --git a/compiler/utils/FastFunctions.hs b/compiler/utils/FastFunctions.hs --- a/compiler/utils/FastFunctions.hs +++ b/compiler/utils/FastFunctions.hs @@ -8,7 +8,7 @@ inlinePerformIO, ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude () diff --git a/compiler/utils/FastString.hs b/compiler/utils/FastString.hs --- a/compiler/utils/FastString.hs +++ b/compiler/utils/FastString.hs @@ -95,7 +95,7 @@ lengthPS ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude as Prelude diff --git a/compiler/utils/ListSetOps.hs b/compiler/utils/ListSetOps.hs --- a/compiler/utils/ListSetOps.hs +++ b/compiler/utils/ListSetOps.hs @@ -21,7 +21,7 @@ getNth ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/utils/Pair.hs b/compiler/utils/Pair.hs --- a/compiler/utils/Pair.hs +++ b/compiler/utils/Pair.hs @@ -7,7 +7,7 @@ module Pair ( Pair(..), unPair, toPair, swap, pLiftFst, pLiftSnd ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/utils/PlainPanic.hs b/compiler/utils/PlainPanic.hs --- a/compiler/utils/PlainPanic.hs +++ b/compiler/utils/PlainPanic.hs @@ -25,7 +25,7 @@ , progName ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import Config import Exception diff --git a/compiler/utils/StringBuffer.hs b/compiler/utils/StringBuffer.hs --- a/compiler/utils/StringBuffer.hs +++ b/compiler/utils/StringBuffer.hs @@ -44,7 +44,7 @@ parseUnsignedInteger, ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/compiler/utils/Util.hs b/compiler/utils/Util.hs --- a/compiler/utils/Util.hs +++ b/compiler/utils/Util.hs @@ -128,7 +128,7 @@ overrideWith, ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/ghc-lib-parser.cabal b/ghc-lib-parser.cabal --- a/ghc-lib-parser.cabal +++ b/ghc-lib-parser.cabal @@ -1,7 +1,7 @@ cabal-version: >=1.22 build-type: Simple name: ghc-lib-parser -version: 8.8.1.20210620 +version: 8.8.2 license: BSD3 license-file: LICENSE category: Development @@ -20,10 +20,11 @@ extra-source-files: ghc-lib/generated/ghcautoconf.h ghc-lib/generated/ghcplatform.h - ghc-lib/generated/GhclibDerivedConstants.h + ghc-lib/generated/ghcversion.h + ghc-lib/generated/DerivedConstants.h ghc-lib/generated/GHCConstantsHaskellExports.hs - ghc-lib/generated/GHCConstantsHaskellWrappers.hs ghc-lib/generated/GHCConstantsHaskellType.hs + ghc-lib/generated/GHCConstantsHaskellWrappers.hs ghc-lib/stage0/compiler/build/primop-can-fail.hs-incl ghc-lib/stage0/compiler/build/primop-code-size.hs-incl ghc-lib/stage0/compiler/build/primop-commutable.hs-incl @@ -48,16 +49,18 @@ includes/MachDeps.h includes/stg/MachRegs.h includes/CodeGen.Platform.hs + compiler/HsVersions.h compiler/Unique.h - compiler/GhclibHsVersions.h compiler/nativeGen/NCG.h compiler/utils/md5.h +tested-with: GHC==8.8.1, GHC==8.6.5, GHC==8.4.3 source-repository head type: git location: git@github.com:digital-asset/ghc-lib.git library default-language: Haskell2010 + default-extensions: NoImplicitPrelude exposed: False include-dirs: includes @@ -73,8 +76,8 @@ else build-depends: Win32 build-depends: - ghc-prim > 0.2 && < 0.8, - base >= 4.11 && < 4.16, + ghc-prim > 0.2 && < 0.6, + base >= 4.11 && < 4.14, containers >= 0.5 && < 0.7, bytestring >= 0.9 && < 0.11, binary == 0.8.*, @@ -121,10 +124,7 @@ TypeSynonymInstances UnboxedTuples UndecidableInstances - default-extensions: - NoImplicitPrelude c-sources: - libraries/ghc-heap/cbits/HeapPrim.cmm compiler/cbits/genSym.c compiler/parser/cutils.c hs-source-dirs: @@ -239,7 +239,6 @@ HsBinds HsDecls HsDoc - HsDumpAst HsExpr HsExtension HsImpExp diff --git a/ghc-lib/generated/DerivedConstants.h b/ghc-lib/generated/DerivedConstants.h new file mode 100644 --- /dev/null +++ b/ghc-lib/generated/DerivedConstants.h @@ -0,0 +1,554 @@ +/* This file is created automatically. Do not edit by hand.*/ + +#define CONTROL_GROUP_CONST_291 291 +#define STD_HDR_SIZE 1 +#define PROF_HDR_SIZE 2 +#define BLOCK_SIZE 4096 +#define MBLOCK_SIZE 1048576 +#define BLOCKS_PER_MBLOCK 252 +#define TICKY_BIN_COUNT 9 +#define OFFSET_StgRegTable_rR1 0 +#define OFFSET_StgRegTable_rR2 8 +#define OFFSET_StgRegTable_rR3 16 +#define OFFSET_StgRegTable_rR4 24 +#define OFFSET_StgRegTable_rR5 32 +#define OFFSET_StgRegTable_rR6 40 +#define OFFSET_StgRegTable_rR7 48 +#define OFFSET_StgRegTable_rR8 56 +#define OFFSET_StgRegTable_rR9 64 +#define OFFSET_StgRegTable_rR10 72 +#define OFFSET_StgRegTable_rF1 80 +#define OFFSET_StgRegTable_rF2 84 +#define OFFSET_StgRegTable_rF3 88 +#define OFFSET_StgRegTable_rF4 92 +#define OFFSET_StgRegTable_rF5 96 +#define OFFSET_StgRegTable_rF6 100 +#define OFFSET_StgRegTable_rD1 104 +#define OFFSET_StgRegTable_rD2 112 +#define OFFSET_StgRegTable_rD3 120 +#define OFFSET_StgRegTable_rD4 128 +#define OFFSET_StgRegTable_rD5 136 +#define OFFSET_StgRegTable_rD6 144 +#define OFFSET_StgRegTable_rXMM1 152 +#define OFFSET_StgRegTable_rXMM2 168 +#define OFFSET_StgRegTable_rXMM3 184 +#define OFFSET_StgRegTable_rXMM4 200 +#define OFFSET_StgRegTable_rXMM5 216 +#define OFFSET_StgRegTable_rXMM6 232 +#define OFFSET_StgRegTable_rYMM1 248 +#define OFFSET_StgRegTable_rYMM2 280 +#define OFFSET_StgRegTable_rYMM3 312 +#define OFFSET_StgRegTable_rYMM4 344 +#define OFFSET_StgRegTable_rYMM5 376 +#define OFFSET_StgRegTable_rYMM6 408 +#define OFFSET_StgRegTable_rZMM1 440 +#define OFFSET_StgRegTable_rZMM2 504 +#define OFFSET_StgRegTable_rZMM3 568 +#define OFFSET_StgRegTable_rZMM4 632 +#define OFFSET_StgRegTable_rZMM5 696 +#define OFFSET_StgRegTable_rZMM6 760 +#define OFFSET_StgRegTable_rL1 824 +#define OFFSET_StgRegTable_rSp 832 +#define OFFSET_StgRegTable_rSpLim 840 +#define OFFSET_StgRegTable_rHp 848 +#define OFFSET_StgRegTable_rHpLim 856 +#define OFFSET_StgRegTable_rCCCS 864 +#define OFFSET_StgRegTable_rCurrentTSO 872 +#define OFFSET_StgRegTable_rCurrentNursery 888 +#define OFFSET_StgRegTable_rHpAlloc 904 +#define OFFSET_StgRegTable_rRet 912 +#define REP_StgRegTable_rRet b64 +#define StgRegTable_rRet(__ptr__) REP_StgRegTable_rRet[__ptr__+OFFSET_StgRegTable_rRet] +#define OFFSET_StgRegTable_rNursery 880 +#define REP_StgRegTable_rNursery b64 +#define StgRegTable_rNursery(__ptr__) REP_StgRegTable_rNursery[__ptr__+OFFSET_StgRegTable_rNursery] +#define OFFSET_stgEagerBlackholeInfo -24 +#define OFFSET_stgGCEnter1 -16 +#define OFFSET_stgGCFun -8 +#define OFFSET_Capability_r 24 +#define OFFSET_Capability_lock 1096 +#define OFFSET_Capability_no 944 +#define REP_Capability_no b32 +#define Capability_no(__ptr__) REP_Capability_no[__ptr__+OFFSET_Capability_no] +#define OFFSET_Capability_mut_lists 1016 +#define REP_Capability_mut_lists b64 +#define Capability_mut_lists(__ptr__) REP_Capability_mut_lists[__ptr__+OFFSET_Capability_mut_lists] +#define OFFSET_Capability_context_switch 1064 +#define REP_Capability_context_switch b32 +#define Capability_context_switch(__ptr__) REP_Capability_context_switch[__ptr__+OFFSET_Capability_context_switch] +#define OFFSET_Capability_interrupt 1068 +#define REP_Capability_interrupt b32 +#define Capability_interrupt(__ptr__) REP_Capability_interrupt[__ptr__+OFFSET_Capability_interrupt] +#define OFFSET_Capability_sparks 1200 +#define REP_Capability_sparks b64 +#define Capability_sparks(__ptr__) REP_Capability_sparks[__ptr__+OFFSET_Capability_sparks] +#define OFFSET_Capability_total_allocated 1072 +#define REP_Capability_total_allocated b64 +#define Capability_total_allocated(__ptr__) REP_Capability_total_allocated[__ptr__+OFFSET_Capability_total_allocated] +#define OFFSET_Capability_weak_ptr_list_hd 1048 +#define REP_Capability_weak_ptr_list_hd b64 +#define Capability_weak_ptr_list_hd(__ptr__) REP_Capability_weak_ptr_list_hd[__ptr__+OFFSET_Capability_weak_ptr_list_hd] +#define OFFSET_Capability_weak_ptr_list_tl 1056 +#define REP_Capability_weak_ptr_list_tl b64 +#define Capability_weak_ptr_list_tl(__ptr__) REP_Capability_weak_ptr_list_tl[__ptr__+OFFSET_Capability_weak_ptr_list_tl] +#define OFFSET_bdescr_start 0 +#define REP_bdescr_start b64 +#define bdescr_start(__ptr__) REP_bdescr_start[__ptr__+OFFSET_bdescr_start] +#define OFFSET_bdescr_free 8 +#define REP_bdescr_free b64 +#define bdescr_free(__ptr__) REP_bdescr_free[__ptr__+OFFSET_bdescr_free] +#define OFFSET_bdescr_blocks 48 +#define REP_bdescr_blocks b32 +#define bdescr_blocks(__ptr__) REP_bdescr_blocks[__ptr__+OFFSET_bdescr_blocks] +#define OFFSET_bdescr_gen_no 40 +#define REP_bdescr_gen_no b16 +#define bdescr_gen_no(__ptr__) REP_bdescr_gen_no[__ptr__+OFFSET_bdescr_gen_no] +#define OFFSET_bdescr_link 16 +#define REP_bdescr_link b64 +#define bdescr_link(__ptr__) REP_bdescr_link[__ptr__+OFFSET_bdescr_link] +#define OFFSET_bdescr_flags 46 +#define REP_bdescr_flags b16 +#define bdescr_flags(__ptr__) REP_bdescr_flags[__ptr__+OFFSET_bdescr_flags] +#define SIZEOF_generation 384 +#define OFFSET_generation_n_new_large_words 56 +#define REP_generation_n_new_large_words b64 +#define generation_n_new_large_words(__ptr__) REP_generation_n_new_large_words[__ptr__+OFFSET_generation_n_new_large_words] +#define OFFSET_generation_weak_ptr_list 112 +#define REP_generation_weak_ptr_list b64 +#define generation_weak_ptr_list(__ptr__) REP_generation_weak_ptr_list[__ptr__+OFFSET_generation_weak_ptr_list] +#define SIZEOF_CostCentreStack 96 +#define OFFSET_CostCentreStack_ccsID 0 +#define REP_CostCentreStack_ccsID b64 +#define CostCentreStack_ccsID(__ptr__) REP_CostCentreStack_ccsID[__ptr__+OFFSET_CostCentreStack_ccsID] +#define OFFSET_CostCentreStack_mem_alloc 72 +#define REP_CostCentreStack_mem_alloc b64 +#define CostCentreStack_mem_alloc(__ptr__) REP_CostCentreStack_mem_alloc[__ptr__+OFFSET_CostCentreStack_mem_alloc] +#define OFFSET_CostCentreStack_scc_count 48 +#define REP_CostCentreStack_scc_count b64 +#define CostCentreStack_scc_count(__ptr__) REP_CostCentreStack_scc_count[__ptr__+OFFSET_CostCentreStack_scc_count] +#define OFFSET_CostCentreStack_prevStack 16 +#define REP_CostCentreStack_prevStack b64 +#define CostCentreStack_prevStack(__ptr__) REP_CostCentreStack_prevStack[__ptr__+OFFSET_CostCentreStack_prevStack] +#define OFFSET_CostCentre_ccID 0 +#define REP_CostCentre_ccID b64 +#define CostCentre_ccID(__ptr__) REP_CostCentre_ccID[__ptr__+OFFSET_CostCentre_ccID] +#define OFFSET_CostCentre_link 56 +#define REP_CostCentre_link b64 +#define CostCentre_link(__ptr__) REP_CostCentre_link[__ptr__+OFFSET_CostCentre_link] +#define OFFSET_StgHeader_info 0 +#define REP_StgHeader_info b64 +#define StgHeader_info(__ptr__) REP_StgHeader_info[__ptr__+OFFSET_StgHeader_info] +#define OFFSET_StgHeader_ccs 8 +#define REP_StgHeader_ccs b64 +#define StgHeader_ccs(__ptr__) REP_StgHeader_ccs[__ptr__+OFFSET_StgHeader_ccs] +#define OFFSET_StgHeader_ldvw 16 +#define REP_StgHeader_ldvw b64 +#define StgHeader_ldvw(__ptr__) REP_StgHeader_ldvw[__ptr__+OFFSET_StgHeader_ldvw] +#define SIZEOF_StgSMPThunkHeader 8 +#define OFFSET_StgClosure_payload 0 +#define StgClosure_payload(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgClosure_payload + WDS(__ix__)] +#define OFFSET_StgEntCounter_allocs 48 +#define REP_StgEntCounter_allocs b64 +#define StgEntCounter_allocs(__ptr__) REP_StgEntCounter_allocs[__ptr__+OFFSET_StgEntCounter_allocs] +#define OFFSET_StgEntCounter_allocd 16 +#define REP_StgEntCounter_allocd b64 +#define StgEntCounter_allocd(__ptr__) REP_StgEntCounter_allocd[__ptr__+OFFSET_StgEntCounter_allocd] +#define OFFSET_StgEntCounter_registeredp 0 +#define REP_StgEntCounter_registeredp b64 +#define StgEntCounter_registeredp(__ptr__) REP_StgEntCounter_registeredp[__ptr__+OFFSET_StgEntCounter_registeredp] +#define OFFSET_StgEntCounter_link 56 +#define REP_StgEntCounter_link b64 +#define StgEntCounter_link(__ptr__) REP_StgEntCounter_link[__ptr__+OFFSET_StgEntCounter_link] +#define OFFSET_StgEntCounter_entry_count 40 +#define REP_StgEntCounter_entry_count b64 +#define StgEntCounter_entry_count(__ptr__) REP_StgEntCounter_entry_count[__ptr__+OFFSET_StgEntCounter_entry_count] +#define SIZEOF_StgUpdateFrame_NoHdr 8 +#define SIZEOF_StgUpdateFrame (SIZEOF_StgHeader+8) +#define SIZEOF_StgCatchFrame_NoHdr 16 +#define SIZEOF_StgCatchFrame (SIZEOF_StgHeader+16) +#define SIZEOF_StgStopFrame_NoHdr 0 +#define SIZEOF_StgStopFrame (SIZEOF_StgHeader+0) +#define SIZEOF_StgMutArrPtrs_NoHdr 16 +#define SIZEOF_StgMutArrPtrs (SIZEOF_StgHeader+16) +#define OFFSET_StgMutArrPtrs_ptrs 0 +#define REP_StgMutArrPtrs_ptrs b64 +#define StgMutArrPtrs_ptrs(__ptr__) REP_StgMutArrPtrs_ptrs[__ptr__+SIZEOF_StgHeader+OFFSET_StgMutArrPtrs_ptrs] +#define OFFSET_StgMutArrPtrs_size 8 +#define REP_StgMutArrPtrs_size b64 +#define StgMutArrPtrs_size(__ptr__) REP_StgMutArrPtrs_size[__ptr__+SIZEOF_StgHeader+OFFSET_StgMutArrPtrs_size] +#define SIZEOF_StgSmallMutArrPtrs_NoHdr 8 +#define SIZEOF_StgSmallMutArrPtrs (SIZEOF_StgHeader+8) +#define OFFSET_StgSmallMutArrPtrs_ptrs 0 +#define REP_StgSmallMutArrPtrs_ptrs b64 +#define StgSmallMutArrPtrs_ptrs(__ptr__) REP_StgSmallMutArrPtrs_ptrs[__ptr__+SIZEOF_StgHeader+OFFSET_StgSmallMutArrPtrs_ptrs] +#define SIZEOF_StgArrBytes_NoHdr 8 +#define SIZEOF_StgArrBytes (SIZEOF_StgHeader+8) +#define OFFSET_StgArrBytes_bytes 0 +#define REP_StgArrBytes_bytes b64 +#define StgArrBytes_bytes(__ptr__) REP_StgArrBytes_bytes[__ptr__+SIZEOF_StgHeader+OFFSET_StgArrBytes_bytes] +#define OFFSET_StgArrBytes_payload 8 +#define StgArrBytes_payload(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgArrBytes_payload + WDS(__ix__)] +#define OFFSET_StgTSO__link 0 +#define REP_StgTSO__link b64 +#define StgTSO__link(__ptr__) REP_StgTSO__link[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO__link] +#define OFFSET_StgTSO_global_link 8 +#define REP_StgTSO_global_link b64 +#define StgTSO_global_link(__ptr__) REP_StgTSO_global_link[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_global_link] +#define OFFSET_StgTSO_what_next 24 +#define REP_StgTSO_what_next b16 +#define StgTSO_what_next(__ptr__) REP_StgTSO_what_next[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_what_next] +#define OFFSET_StgTSO_why_blocked 26 +#define REP_StgTSO_why_blocked b16 +#define StgTSO_why_blocked(__ptr__) REP_StgTSO_why_blocked[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_why_blocked] +#define OFFSET_StgTSO_block_info 32 +#define REP_StgTSO_block_info b64 +#define StgTSO_block_info(__ptr__) REP_StgTSO_block_info[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_block_info] +#define OFFSET_StgTSO_blocked_exceptions 80 +#define REP_StgTSO_blocked_exceptions b64 +#define StgTSO_blocked_exceptions(__ptr__) REP_StgTSO_blocked_exceptions[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_blocked_exceptions] +#define OFFSET_StgTSO_id 40 +#define REP_StgTSO_id b32 +#define StgTSO_id(__ptr__) REP_StgTSO_id[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_id] +#define OFFSET_StgTSO_cap 64 +#define REP_StgTSO_cap b64 +#define StgTSO_cap(__ptr__) REP_StgTSO_cap[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_cap] +#define OFFSET_StgTSO_saved_errno 44 +#define REP_StgTSO_saved_errno b32 +#define StgTSO_saved_errno(__ptr__) REP_StgTSO_saved_errno[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_saved_errno] +#define OFFSET_StgTSO_trec 72 +#define REP_StgTSO_trec b64 +#define StgTSO_trec(__ptr__) REP_StgTSO_trec[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_trec] +#define OFFSET_StgTSO_flags 28 +#define REP_StgTSO_flags b32 +#define StgTSO_flags(__ptr__) REP_StgTSO_flags[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_flags] +#define OFFSET_StgTSO_dirty 48 +#define REP_StgTSO_dirty b32 +#define StgTSO_dirty(__ptr__) REP_StgTSO_dirty[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_dirty] +#define OFFSET_StgTSO_bq 88 +#define REP_StgTSO_bq b64 +#define StgTSO_bq(__ptr__) REP_StgTSO_bq[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_bq] +#define OFFSET_StgTSO_alloc_limit 96 +#define REP_StgTSO_alloc_limit b64 +#define StgTSO_alloc_limit(__ptr__) REP_StgTSO_alloc_limit[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_alloc_limit] +#define OFFSET_StgTSO_cccs 112 +#define REP_StgTSO_cccs b64 +#define StgTSO_cccs(__ptr__) REP_StgTSO_cccs[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_cccs] +#define OFFSET_StgTSO_stackobj 16 +#define REP_StgTSO_stackobj b64 +#define StgTSO_stackobj(__ptr__) REP_StgTSO_stackobj[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_stackobj] +#define OFFSET_StgStack_sp 8 +#define REP_StgStack_sp b64 +#define StgStack_sp(__ptr__) REP_StgStack_sp[__ptr__+SIZEOF_StgHeader+OFFSET_StgStack_sp] +#define OFFSET_StgStack_stack 16 +#define OFFSET_StgStack_stack_size 0 +#define REP_StgStack_stack_size b32 +#define StgStack_stack_size(__ptr__) REP_StgStack_stack_size[__ptr__+SIZEOF_StgHeader+OFFSET_StgStack_stack_size] +#define OFFSET_StgStack_dirty 4 +#define REP_StgStack_dirty b32 +#define StgStack_dirty(__ptr__) REP_StgStack_dirty[__ptr__+SIZEOF_StgHeader+OFFSET_StgStack_dirty] +#define SIZEOF_StgTSOProfInfo 8 +#define OFFSET_StgUpdateFrame_updatee 0 +#define REP_StgUpdateFrame_updatee b64 +#define StgUpdateFrame_updatee(__ptr__) REP_StgUpdateFrame_updatee[__ptr__+SIZEOF_StgHeader+OFFSET_StgUpdateFrame_updatee] +#define OFFSET_StgCatchFrame_handler 8 +#define REP_StgCatchFrame_handler b64 +#define StgCatchFrame_handler(__ptr__) REP_StgCatchFrame_handler[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchFrame_handler] +#define OFFSET_StgCatchFrame_exceptions_blocked 0 +#define REP_StgCatchFrame_exceptions_blocked b64 +#define StgCatchFrame_exceptions_blocked(__ptr__) REP_StgCatchFrame_exceptions_blocked[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchFrame_exceptions_blocked] +#define SIZEOF_StgPAP_NoHdr 16 +#define SIZEOF_StgPAP (SIZEOF_StgHeader+16) +#define OFFSET_StgPAP_n_args 4 +#define REP_StgPAP_n_args b32 +#define StgPAP_n_args(__ptr__) REP_StgPAP_n_args[__ptr__+SIZEOF_StgHeader+OFFSET_StgPAP_n_args] +#define OFFSET_StgPAP_fun 8 +#define REP_StgPAP_fun gcptr +#define StgPAP_fun(__ptr__) REP_StgPAP_fun[__ptr__+SIZEOF_StgHeader+OFFSET_StgPAP_fun] +#define OFFSET_StgPAP_arity 0 +#define REP_StgPAP_arity b32 +#define StgPAP_arity(__ptr__) REP_StgPAP_arity[__ptr__+SIZEOF_StgHeader+OFFSET_StgPAP_arity] +#define OFFSET_StgPAP_payload 16 +#define StgPAP_payload(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgPAP_payload + WDS(__ix__)] +#define SIZEOF_StgAP_NoThunkHdr 16 +#define SIZEOF_StgAP_NoHdr 24 +#define SIZEOF_StgAP (SIZEOF_StgHeader+24) +#define OFFSET_StgAP_n_args 12 +#define REP_StgAP_n_args b32 +#define StgAP_n_args(__ptr__) REP_StgAP_n_args[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_n_args] +#define OFFSET_StgAP_fun 16 +#define REP_StgAP_fun gcptr +#define StgAP_fun(__ptr__) REP_StgAP_fun[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_fun] +#define OFFSET_StgAP_payload 24 +#define StgAP_payload(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_payload + WDS(__ix__)] +#define SIZEOF_StgAP_STACK_NoThunkHdr 16 +#define SIZEOF_StgAP_STACK_NoHdr 24 +#define SIZEOF_StgAP_STACK (SIZEOF_StgHeader+24) +#define OFFSET_StgAP_STACK_size 8 +#define REP_StgAP_STACK_size b64 +#define StgAP_STACK_size(__ptr__) REP_StgAP_STACK_size[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_STACK_size] +#define OFFSET_StgAP_STACK_fun 16 +#define REP_StgAP_STACK_fun gcptr +#define StgAP_STACK_fun(__ptr__) REP_StgAP_STACK_fun[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_STACK_fun] +#define OFFSET_StgAP_STACK_payload 24 +#define StgAP_STACK_payload(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_STACK_payload + WDS(__ix__)] +#define SIZEOF_StgSelector_NoThunkHdr 8 +#define SIZEOF_StgSelector_NoHdr 16 +#define SIZEOF_StgSelector (SIZEOF_StgHeader+16) +#define OFFSET_StgInd_indirectee 0 +#define REP_StgInd_indirectee gcptr +#define StgInd_indirectee(__ptr__) REP_StgInd_indirectee[__ptr__+SIZEOF_StgHeader+OFFSET_StgInd_indirectee] +#define SIZEOF_StgMutVar_NoHdr 8 +#define SIZEOF_StgMutVar (SIZEOF_StgHeader+8) +#define OFFSET_StgMutVar_var 0 +#define REP_StgMutVar_var b64 +#define StgMutVar_var(__ptr__) REP_StgMutVar_var[__ptr__+SIZEOF_StgHeader+OFFSET_StgMutVar_var] +#define SIZEOF_StgAtomicallyFrame_NoHdr 16 +#define SIZEOF_StgAtomicallyFrame (SIZEOF_StgHeader+16) +#define OFFSET_StgAtomicallyFrame_code 0 +#define REP_StgAtomicallyFrame_code b64 +#define StgAtomicallyFrame_code(__ptr__) REP_StgAtomicallyFrame_code[__ptr__+SIZEOF_StgHeader+OFFSET_StgAtomicallyFrame_code] +#define OFFSET_StgAtomicallyFrame_result 8 +#define REP_StgAtomicallyFrame_result b64 +#define StgAtomicallyFrame_result(__ptr__) REP_StgAtomicallyFrame_result[__ptr__+SIZEOF_StgHeader+OFFSET_StgAtomicallyFrame_result] +#define OFFSET_StgTRecHeader_enclosing_trec 0 +#define REP_StgTRecHeader_enclosing_trec b64 +#define StgTRecHeader_enclosing_trec(__ptr__) REP_StgTRecHeader_enclosing_trec[__ptr__+SIZEOF_StgHeader+OFFSET_StgTRecHeader_enclosing_trec] +#define SIZEOF_StgCatchSTMFrame_NoHdr 16 +#define SIZEOF_StgCatchSTMFrame (SIZEOF_StgHeader+16) +#define OFFSET_StgCatchSTMFrame_handler 8 +#define REP_StgCatchSTMFrame_handler b64 +#define StgCatchSTMFrame_handler(__ptr__) REP_StgCatchSTMFrame_handler[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchSTMFrame_handler] +#define OFFSET_StgCatchSTMFrame_code 0 +#define REP_StgCatchSTMFrame_code b64 +#define StgCatchSTMFrame_code(__ptr__) REP_StgCatchSTMFrame_code[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchSTMFrame_code] +#define SIZEOF_StgCatchRetryFrame_NoHdr 24 +#define SIZEOF_StgCatchRetryFrame (SIZEOF_StgHeader+24) +#define OFFSET_StgCatchRetryFrame_running_alt_code 0 +#define REP_StgCatchRetryFrame_running_alt_code b64 +#define StgCatchRetryFrame_running_alt_code(__ptr__) REP_StgCatchRetryFrame_running_alt_code[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchRetryFrame_running_alt_code] +#define OFFSET_StgCatchRetryFrame_first_code 8 +#define REP_StgCatchRetryFrame_first_code b64 +#define StgCatchRetryFrame_first_code(__ptr__) REP_StgCatchRetryFrame_first_code[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchRetryFrame_first_code] +#define OFFSET_StgCatchRetryFrame_alt_code 16 +#define REP_StgCatchRetryFrame_alt_code b64 +#define StgCatchRetryFrame_alt_code(__ptr__) REP_StgCatchRetryFrame_alt_code[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchRetryFrame_alt_code] +#define OFFSET_StgTVarWatchQueue_closure 0 +#define REP_StgTVarWatchQueue_closure b64 +#define StgTVarWatchQueue_closure(__ptr__) REP_StgTVarWatchQueue_closure[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVarWatchQueue_closure] +#define OFFSET_StgTVarWatchQueue_next_queue_entry 8 +#define REP_StgTVarWatchQueue_next_queue_entry b64 +#define StgTVarWatchQueue_next_queue_entry(__ptr__) REP_StgTVarWatchQueue_next_queue_entry[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVarWatchQueue_next_queue_entry] +#define OFFSET_StgTVarWatchQueue_prev_queue_entry 16 +#define REP_StgTVarWatchQueue_prev_queue_entry b64 +#define StgTVarWatchQueue_prev_queue_entry(__ptr__) REP_StgTVarWatchQueue_prev_queue_entry[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVarWatchQueue_prev_queue_entry] +#define SIZEOF_StgTVar_NoHdr 24 +#define SIZEOF_StgTVar (SIZEOF_StgHeader+24) +#define OFFSET_StgTVar_current_value 0 +#define REP_StgTVar_current_value b64 +#define StgTVar_current_value(__ptr__) REP_StgTVar_current_value[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVar_current_value] +#define OFFSET_StgTVar_first_watch_queue_entry 8 +#define REP_StgTVar_first_watch_queue_entry b64 +#define StgTVar_first_watch_queue_entry(__ptr__) REP_StgTVar_first_watch_queue_entry[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVar_first_watch_queue_entry] +#define OFFSET_StgTVar_num_updates 16 +#define REP_StgTVar_num_updates b64 +#define StgTVar_num_updates(__ptr__) REP_StgTVar_num_updates[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVar_num_updates] +#define SIZEOF_StgWeak_NoHdr 40 +#define SIZEOF_StgWeak (SIZEOF_StgHeader+40) +#define OFFSET_StgWeak_link 32 +#define REP_StgWeak_link b64 +#define StgWeak_link(__ptr__) REP_StgWeak_link[__ptr__+SIZEOF_StgHeader+OFFSET_StgWeak_link] +#define OFFSET_StgWeak_key 8 +#define REP_StgWeak_key b64 +#define StgWeak_key(__ptr__) REP_StgWeak_key[__ptr__+SIZEOF_StgHeader+OFFSET_StgWeak_key] +#define OFFSET_StgWeak_value 16 +#define REP_StgWeak_value b64 +#define StgWeak_value(__ptr__) REP_StgWeak_value[__ptr__+SIZEOF_StgHeader+OFFSET_StgWeak_value] +#define OFFSET_StgWeak_finalizer 24 +#define REP_StgWeak_finalizer b64 +#define StgWeak_finalizer(__ptr__) REP_StgWeak_finalizer[__ptr__+SIZEOF_StgHeader+OFFSET_StgWeak_finalizer] +#define OFFSET_StgWeak_cfinalizers 0 +#define REP_StgWeak_cfinalizers b64 +#define StgWeak_cfinalizers(__ptr__) REP_StgWeak_cfinalizers[__ptr__+SIZEOF_StgHeader+OFFSET_StgWeak_cfinalizers] +#define SIZEOF_StgCFinalizerList_NoHdr 40 +#define SIZEOF_StgCFinalizerList (SIZEOF_StgHeader+40) +#define OFFSET_StgCFinalizerList_link 0 +#define REP_StgCFinalizerList_link b64 +#define StgCFinalizerList_link(__ptr__) REP_StgCFinalizerList_link[__ptr__+SIZEOF_StgHeader+OFFSET_StgCFinalizerList_link] +#define OFFSET_StgCFinalizerList_fptr 8 +#define REP_StgCFinalizerList_fptr b64 +#define StgCFinalizerList_fptr(__ptr__) REP_StgCFinalizerList_fptr[__ptr__+SIZEOF_StgHeader+OFFSET_StgCFinalizerList_fptr] +#define OFFSET_StgCFinalizerList_ptr 16 +#define REP_StgCFinalizerList_ptr b64 +#define StgCFinalizerList_ptr(__ptr__) REP_StgCFinalizerList_ptr[__ptr__+SIZEOF_StgHeader+OFFSET_StgCFinalizerList_ptr] +#define OFFSET_StgCFinalizerList_eptr 24 +#define REP_StgCFinalizerList_eptr b64 +#define StgCFinalizerList_eptr(__ptr__) REP_StgCFinalizerList_eptr[__ptr__+SIZEOF_StgHeader+OFFSET_StgCFinalizerList_eptr] +#define OFFSET_StgCFinalizerList_flag 32 +#define REP_StgCFinalizerList_flag b64 +#define StgCFinalizerList_flag(__ptr__) REP_StgCFinalizerList_flag[__ptr__+SIZEOF_StgHeader+OFFSET_StgCFinalizerList_flag] +#define SIZEOF_StgMVar_NoHdr 24 +#define SIZEOF_StgMVar (SIZEOF_StgHeader+24) +#define OFFSET_StgMVar_head 0 +#define REP_StgMVar_head b64 +#define StgMVar_head(__ptr__) REP_StgMVar_head[__ptr__+SIZEOF_StgHeader+OFFSET_StgMVar_head] +#define OFFSET_StgMVar_tail 8 +#define REP_StgMVar_tail b64 +#define StgMVar_tail(__ptr__) REP_StgMVar_tail[__ptr__+SIZEOF_StgHeader+OFFSET_StgMVar_tail] +#define OFFSET_StgMVar_value 16 +#define REP_StgMVar_value b64 +#define StgMVar_value(__ptr__) REP_StgMVar_value[__ptr__+SIZEOF_StgHeader+OFFSET_StgMVar_value] +#define SIZEOF_StgMVarTSOQueue_NoHdr 16 +#define SIZEOF_StgMVarTSOQueue (SIZEOF_StgHeader+16) +#define OFFSET_StgMVarTSOQueue_link 0 +#define REP_StgMVarTSOQueue_link b64 +#define StgMVarTSOQueue_link(__ptr__) REP_StgMVarTSOQueue_link[__ptr__+SIZEOF_StgHeader+OFFSET_StgMVarTSOQueue_link] +#define OFFSET_StgMVarTSOQueue_tso 8 +#define REP_StgMVarTSOQueue_tso b64 +#define StgMVarTSOQueue_tso(__ptr__) REP_StgMVarTSOQueue_tso[__ptr__+SIZEOF_StgHeader+OFFSET_StgMVarTSOQueue_tso] +#define SIZEOF_StgBCO_NoHdr 32 +#define SIZEOF_StgBCO (SIZEOF_StgHeader+32) +#define OFFSET_StgBCO_instrs 0 +#define REP_StgBCO_instrs b64 +#define StgBCO_instrs(__ptr__) REP_StgBCO_instrs[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_instrs] +#define OFFSET_StgBCO_literals 8 +#define REP_StgBCO_literals b64 +#define StgBCO_literals(__ptr__) REP_StgBCO_literals[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_literals] +#define OFFSET_StgBCO_ptrs 16 +#define REP_StgBCO_ptrs b64 +#define StgBCO_ptrs(__ptr__) REP_StgBCO_ptrs[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_ptrs] +#define OFFSET_StgBCO_arity 24 +#define REP_StgBCO_arity b32 +#define StgBCO_arity(__ptr__) REP_StgBCO_arity[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_arity] +#define OFFSET_StgBCO_size 28 +#define REP_StgBCO_size b32 +#define StgBCO_size(__ptr__) REP_StgBCO_size[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_size] +#define OFFSET_StgBCO_bitmap 32 +#define StgBCO_bitmap(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_bitmap + WDS(__ix__)] +#define SIZEOF_StgStableName_NoHdr 8 +#define SIZEOF_StgStableName (SIZEOF_StgHeader+8) +#define OFFSET_StgStableName_sn 0 +#define REP_StgStableName_sn b64 +#define StgStableName_sn(__ptr__) REP_StgStableName_sn[__ptr__+SIZEOF_StgHeader+OFFSET_StgStableName_sn] +#define SIZEOF_StgBlockingQueue_NoHdr 32 +#define SIZEOF_StgBlockingQueue (SIZEOF_StgHeader+32) +#define OFFSET_StgBlockingQueue_bh 8 +#define REP_StgBlockingQueue_bh b64 +#define StgBlockingQueue_bh(__ptr__) REP_StgBlockingQueue_bh[__ptr__+SIZEOF_StgHeader+OFFSET_StgBlockingQueue_bh] +#define OFFSET_StgBlockingQueue_owner 16 +#define REP_StgBlockingQueue_owner b64 +#define StgBlockingQueue_owner(__ptr__) REP_StgBlockingQueue_owner[__ptr__+SIZEOF_StgHeader+OFFSET_StgBlockingQueue_owner] +#define OFFSET_StgBlockingQueue_queue 24 +#define REP_StgBlockingQueue_queue b64 +#define StgBlockingQueue_queue(__ptr__) REP_StgBlockingQueue_queue[__ptr__+SIZEOF_StgHeader+OFFSET_StgBlockingQueue_queue] +#define OFFSET_StgBlockingQueue_link 0 +#define REP_StgBlockingQueue_link b64 +#define StgBlockingQueue_link(__ptr__) REP_StgBlockingQueue_link[__ptr__+SIZEOF_StgHeader+OFFSET_StgBlockingQueue_link] +#define SIZEOF_MessageBlackHole_NoHdr 24 +#define SIZEOF_MessageBlackHole (SIZEOF_StgHeader+24) +#define OFFSET_MessageBlackHole_link 0 +#define REP_MessageBlackHole_link b64 +#define MessageBlackHole_link(__ptr__) REP_MessageBlackHole_link[__ptr__+SIZEOF_StgHeader+OFFSET_MessageBlackHole_link] +#define OFFSET_MessageBlackHole_tso 8 +#define REP_MessageBlackHole_tso b64 +#define MessageBlackHole_tso(__ptr__) REP_MessageBlackHole_tso[__ptr__+SIZEOF_StgHeader+OFFSET_MessageBlackHole_tso] +#define OFFSET_MessageBlackHole_bh 16 +#define REP_MessageBlackHole_bh b64 +#define MessageBlackHole_bh(__ptr__) REP_MessageBlackHole_bh[__ptr__+SIZEOF_StgHeader+OFFSET_MessageBlackHole_bh] +#define SIZEOF_StgCompactNFData_NoHdr 64 +#define SIZEOF_StgCompactNFData (SIZEOF_StgHeader+64) +#define OFFSET_StgCompactNFData_totalW 0 +#define REP_StgCompactNFData_totalW b64 +#define StgCompactNFData_totalW(__ptr__) REP_StgCompactNFData_totalW[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_totalW] +#define OFFSET_StgCompactNFData_autoBlockW 8 +#define REP_StgCompactNFData_autoBlockW b64 +#define StgCompactNFData_autoBlockW(__ptr__) REP_StgCompactNFData_autoBlockW[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_autoBlockW] +#define OFFSET_StgCompactNFData_nursery 32 +#define REP_StgCompactNFData_nursery b64 +#define StgCompactNFData_nursery(__ptr__) REP_StgCompactNFData_nursery[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_nursery] +#define OFFSET_StgCompactNFData_last 40 +#define REP_StgCompactNFData_last b64 +#define StgCompactNFData_last(__ptr__) REP_StgCompactNFData_last[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_last] +#define OFFSET_StgCompactNFData_hp 16 +#define REP_StgCompactNFData_hp b64 +#define StgCompactNFData_hp(__ptr__) REP_StgCompactNFData_hp[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_hp] +#define OFFSET_StgCompactNFData_hpLim 24 +#define REP_StgCompactNFData_hpLim b64 +#define StgCompactNFData_hpLim(__ptr__) REP_StgCompactNFData_hpLim[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_hpLim] +#define OFFSET_StgCompactNFData_hash 48 +#define REP_StgCompactNFData_hash b64 +#define StgCompactNFData_hash(__ptr__) REP_StgCompactNFData_hash[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_hash] +#define OFFSET_StgCompactNFData_result 56 +#define REP_StgCompactNFData_result b64 +#define StgCompactNFData_result(__ptr__) REP_StgCompactNFData_result[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_result] +#define SIZEOF_StgCompactNFDataBlock 24 +#define OFFSET_StgCompactNFDataBlock_self 0 +#define REP_StgCompactNFDataBlock_self b64 +#define StgCompactNFDataBlock_self(__ptr__) REP_StgCompactNFDataBlock_self[__ptr__+OFFSET_StgCompactNFDataBlock_self] +#define OFFSET_StgCompactNFDataBlock_owner 8 +#define REP_StgCompactNFDataBlock_owner b64 +#define StgCompactNFDataBlock_owner(__ptr__) REP_StgCompactNFDataBlock_owner[__ptr__+OFFSET_StgCompactNFDataBlock_owner] +#define OFFSET_StgCompactNFDataBlock_next 16 +#define REP_StgCompactNFDataBlock_next b64 +#define StgCompactNFDataBlock_next(__ptr__) REP_StgCompactNFDataBlock_next[__ptr__+OFFSET_StgCompactNFDataBlock_next] +#define OFFSET_RtsFlags_ProfFlags_showCCSOnException 269 +#define REP_RtsFlags_ProfFlags_showCCSOnException b8 +#define RtsFlags_ProfFlags_showCCSOnException(__ptr__) REP_RtsFlags_ProfFlags_showCCSOnException[__ptr__+OFFSET_RtsFlags_ProfFlags_showCCSOnException] +#define OFFSET_RtsFlags_DebugFlags_apply 210 +#define REP_RtsFlags_DebugFlags_apply b8 +#define RtsFlags_DebugFlags_apply(__ptr__) REP_RtsFlags_DebugFlags_apply[__ptr__+OFFSET_RtsFlags_DebugFlags_apply] +#define OFFSET_RtsFlags_DebugFlags_sanity 206 +#define REP_RtsFlags_DebugFlags_sanity b8 +#define RtsFlags_DebugFlags_sanity(__ptr__) REP_RtsFlags_DebugFlags_sanity[__ptr__+OFFSET_RtsFlags_DebugFlags_sanity] +#define OFFSET_RtsFlags_DebugFlags_weak 202 +#define REP_RtsFlags_DebugFlags_weak b8 +#define RtsFlags_DebugFlags_weak(__ptr__) REP_RtsFlags_DebugFlags_weak[__ptr__+OFFSET_RtsFlags_DebugFlags_weak] +#define OFFSET_RtsFlags_GcFlags_initialStkSize 16 +#define REP_RtsFlags_GcFlags_initialStkSize b32 +#define RtsFlags_GcFlags_initialStkSize(__ptr__) REP_RtsFlags_GcFlags_initialStkSize[__ptr__+OFFSET_RtsFlags_GcFlags_initialStkSize] +#define OFFSET_RtsFlags_MiscFlags_tickInterval 176 +#define REP_RtsFlags_MiscFlags_tickInterval b64 +#define RtsFlags_MiscFlags_tickInterval(__ptr__) REP_RtsFlags_MiscFlags_tickInterval[__ptr__+OFFSET_RtsFlags_MiscFlags_tickInterval] +#define SIZEOF_StgFunInfoExtraFwd 32 +#define OFFSET_StgFunInfoExtraFwd_slow_apply 24 +#define REP_StgFunInfoExtraFwd_slow_apply b64 +#define StgFunInfoExtraFwd_slow_apply(__ptr__) REP_StgFunInfoExtraFwd_slow_apply[__ptr__+OFFSET_StgFunInfoExtraFwd_slow_apply] +#define OFFSET_StgFunInfoExtraFwd_fun_type 0 +#define REP_StgFunInfoExtraFwd_fun_type b32 +#define StgFunInfoExtraFwd_fun_type(__ptr__) REP_StgFunInfoExtraFwd_fun_type[__ptr__+OFFSET_StgFunInfoExtraFwd_fun_type] +#define OFFSET_StgFunInfoExtraFwd_arity 4 +#define REP_StgFunInfoExtraFwd_arity b32 +#define StgFunInfoExtraFwd_arity(__ptr__) REP_StgFunInfoExtraFwd_arity[__ptr__+OFFSET_StgFunInfoExtraFwd_arity] +#define OFFSET_StgFunInfoExtraFwd_bitmap 16 +#define REP_StgFunInfoExtraFwd_bitmap b64 +#define StgFunInfoExtraFwd_bitmap(__ptr__) REP_StgFunInfoExtraFwd_bitmap[__ptr__+OFFSET_StgFunInfoExtraFwd_bitmap] +#define SIZEOF_StgFunInfoExtraRev 24 +#define OFFSET_StgFunInfoExtraRev_slow_apply_offset 0 +#define REP_StgFunInfoExtraRev_slow_apply_offset b32 +#define StgFunInfoExtraRev_slow_apply_offset(__ptr__) REP_StgFunInfoExtraRev_slow_apply_offset[__ptr__+OFFSET_StgFunInfoExtraRev_slow_apply_offset] +#define OFFSET_StgFunInfoExtraRev_fun_type 16 +#define REP_StgFunInfoExtraRev_fun_type b32 +#define StgFunInfoExtraRev_fun_type(__ptr__) REP_StgFunInfoExtraRev_fun_type[__ptr__+OFFSET_StgFunInfoExtraRev_fun_type] +#define OFFSET_StgFunInfoExtraRev_arity 20 +#define REP_StgFunInfoExtraRev_arity b32 +#define StgFunInfoExtraRev_arity(__ptr__) REP_StgFunInfoExtraRev_arity[__ptr__+OFFSET_StgFunInfoExtraRev_arity] +#define OFFSET_StgFunInfoExtraRev_bitmap 8 +#define REP_StgFunInfoExtraRev_bitmap b64 +#define StgFunInfoExtraRev_bitmap(__ptr__) REP_StgFunInfoExtraRev_bitmap[__ptr__+OFFSET_StgFunInfoExtraRev_bitmap] +#define OFFSET_StgFunInfoExtraRev_bitmap_offset 8 +#define REP_StgFunInfoExtraRev_bitmap_offset b32 +#define StgFunInfoExtraRev_bitmap_offset(__ptr__) REP_StgFunInfoExtraRev_bitmap_offset[__ptr__+OFFSET_StgFunInfoExtraRev_bitmap_offset] +#define OFFSET_StgLargeBitmap_size 0 +#define REP_StgLargeBitmap_size b64 +#define StgLargeBitmap_size(__ptr__) REP_StgLargeBitmap_size[__ptr__+OFFSET_StgLargeBitmap_size] +#define OFFSET_StgLargeBitmap_bitmap 8 +#define SIZEOF_snEntry 24 +#define OFFSET_snEntry_sn_obj 16 +#define REP_snEntry_sn_obj b64 +#define snEntry_sn_obj(__ptr__) REP_snEntry_sn_obj[__ptr__+OFFSET_snEntry_sn_obj] +#define OFFSET_snEntry_addr 0 +#define REP_snEntry_addr b64 +#define snEntry_addr(__ptr__) REP_snEntry_addr[__ptr__+OFFSET_snEntry_addr] +#define SIZEOF_spEntry 8 +#define OFFSET_spEntry_addr 0 +#define REP_spEntry_addr b64 +#define spEntry_addr(__ptr__) REP_spEntry_addr[__ptr__+OFFSET_spEntry_addr] diff --git a/ghc-lib/generated/GhclibDerivedConstants.h b/ghc-lib/generated/GhclibDerivedConstants.h deleted file mode 100644 --- a/ghc-lib/generated/GhclibDerivedConstants.h +++ /dev/null @@ -1,554 +0,0 @@ -/* This file is created automatically. Do not edit by hand.*/ - -#define CONTROL_GROUP_CONST_291 291 -#define STD_HDR_SIZE 1 -#define PROF_HDR_SIZE 2 -#define BLOCK_SIZE 4096 -#define MBLOCK_SIZE 1048576 -#define BLOCKS_PER_MBLOCK 252 -#define TICKY_BIN_COUNT 9 -#define OFFSET_StgRegTable_rR1 0 -#define OFFSET_StgRegTable_rR2 8 -#define OFFSET_StgRegTable_rR3 16 -#define OFFSET_StgRegTable_rR4 24 -#define OFFSET_StgRegTable_rR5 32 -#define OFFSET_StgRegTable_rR6 40 -#define OFFSET_StgRegTable_rR7 48 -#define OFFSET_StgRegTable_rR8 56 -#define OFFSET_StgRegTable_rR9 64 -#define OFFSET_StgRegTable_rR10 72 -#define OFFSET_StgRegTable_rF1 80 -#define OFFSET_StgRegTable_rF2 84 -#define OFFSET_StgRegTable_rF3 88 -#define OFFSET_StgRegTable_rF4 92 -#define OFFSET_StgRegTable_rF5 96 -#define OFFSET_StgRegTable_rF6 100 -#define OFFSET_StgRegTable_rD1 104 -#define OFFSET_StgRegTable_rD2 112 -#define OFFSET_StgRegTable_rD3 120 -#define OFFSET_StgRegTable_rD4 128 -#define OFFSET_StgRegTable_rD5 136 -#define OFFSET_StgRegTable_rD6 144 -#define OFFSET_StgRegTable_rXMM1 152 -#define OFFSET_StgRegTable_rXMM2 168 -#define OFFSET_StgRegTable_rXMM3 184 -#define OFFSET_StgRegTable_rXMM4 200 -#define OFFSET_StgRegTable_rXMM5 216 -#define OFFSET_StgRegTable_rXMM6 232 -#define OFFSET_StgRegTable_rYMM1 248 -#define OFFSET_StgRegTable_rYMM2 280 -#define OFFSET_StgRegTable_rYMM3 312 -#define OFFSET_StgRegTable_rYMM4 344 -#define OFFSET_StgRegTable_rYMM5 376 -#define OFFSET_StgRegTable_rYMM6 408 -#define OFFSET_StgRegTable_rZMM1 440 -#define OFFSET_StgRegTable_rZMM2 504 -#define OFFSET_StgRegTable_rZMM3 568 -#define OFFSET_StgRegTable_rZMM4 632 -#define OFFSET_StgRegTable_rZMM5 696 -#define OFFSET_StgRegTable_rZMM6 760 -#define OFFSET_StgRegTable_rL1 824 -#define OFFSET_StgRegTable_rSp 832 -#define OFFSET_StgRegTable_rSpLim 840 -#define OFFSET_StgRegTable_rHp 848 -#define OFFSET_StgRegTable_rHpLim 856 -#define OFFSET_StgRegTable_rCCCS 864 -#define OFFSET_StgRegTable_rCurrentTSO 872 -#define OFFSET_StgRegTable_rCurrentNursery 888 -#define OFFSET_StgRegTable_rHpAlloc 904 -#define OFFSET_StgRegTable_rRet 912 -#define REP_StgRegTable_rRet b64 -#define StgRegTable_rRet(__ptr__) REP_StgRegTable_rRet[__ptr__+OFFSET_StgRegTable_rRet] -#define OFFSET_StgRegTable_rNursery 880 -#define REP_StgRegTable_rNursery b64 -#define StgRegTable_rNursery(__ptr__) REP_StgRegTable_rNursery[__ptr__+OFFSET_StgRegTable_rNursery] -#define OFFSET_stgEagerBlackholeInfo -24 -#define OFFSET_stgGCEnter1 -16 -#define OFFSET_stgGCFun -8 -#define OFFSET_Capability_r 24 -#define OFFSET_Capability_lock 1096 -#define OFFSET_Capability_no 944 -#define REP_Capability_no b32 -#define Capability_no(__ptr__) REP_Capability_no[__ptr__+OFFSET_Capability_no] -#define OFFSET_Capability_mut_lists 1016 -#define REP_Capability_mut_lists b64 -#define Capability_mut_lists(__ptr__) REP_Capability_mut_lists[__ptr__+OFFSET_Capability_mut_lists] -#define OFFSET_Capability_context_switch 1064 -#define REP_Capability_context_switch b32 -#define Capability_context_switch(__ptr__) REP_Capability_context_switch[__ptr__+OFFSET_Capability_context_switch] -#define OFFSET_Capability_interrupt 1068 -#define REP_Capability_interrupt b32 -#define Capability_interrupt(__ptr__) REP_Capability_interrupt[__ptr__+OFFSET_Capability_interrupt] -#define OFFSET_Capability_sparks 1200 -#define REP_Capability_sparks b64 -#define Capability_sparks(__ptr__) REP_Capability_sparks[__ptr__+OFFSET_Capability_sparks] -#define OFFSET_Capability_total_allocated 1072 -#define REP_Capability_total_allocated b64 -#define Capability_total_allocated(__ptr__) REP_Capability_total_allocated[__ptr__+OFFSET_Capability_total_allocated] -#define OFFSET_Capability_weak_ptr_list_hd 1048 -#define REP_Capability_weak_ptr_list_hd b64 -#define Capability_weak_ptr_list_hd(__ptr__) REP_Capability_weak_ptr_list_hd[__ptr__+OFFSET_Capability_weak_ptr_list_hd] -#define OFFSET_Capability_weak_ptr_list_tl 1056 -#define REP_Capability_weak_ptr_list_tl b64 -#define Capability_weak_ptr_list_tl(__ptr__) REP_Capability_weak_ptr_list_tl[__ptr__+OFFSET_Capability_weak_ptr_list_tl] -#define OFFSET_bdescr_start 0 -#define REP_bdescr_start b64 -#define bdescr_start(__ptr__) REP_bdescr_start[__ptr__+OFFSET_bdescr_start] -#define OFFSET_bdescr_free 8 -#define REP_bdescr_free b64 -#define bdescr_free(__ptr__) REP_bdescr_free[__ptr__+OFFSET_bdescr_free] -#define OFFSET_bdescr_blocks 48 -#define REP_bdescr_blocks b32 -#define bdescr_blocks(__ptr__) REP_bdescr_blocks[__ptr__+OFFSET_bdescr_blocks] -#define OFFSET_bdescr_gen_no 40 -#define REP_bdescr_gen_no b16 -#define bdescr_gen_no(__ptr__) REP_bdescr_gen_no[__ptr__+OFFSET_bdescr_gen_no] -#define OFFSET_bdescr_link 16 -#define REP_bdescr_link b64 -#define bdescr_link(__ptr__) REP_bdescr_link[__ptr__+OFFSET_bdescr_link] -#define OFFSET_bdescr_flags 46 -#define REP_bdescr_flags b16 -#define bdescr_flags(__ptr__) REP_bdescr_flags[__ptr__+OFFSET_bdescr_flags] -#define SIZEOF_generation 384 -#define OFFSET_generation_n_new_large_words 56 -#define REP_generation_n_new_large_words b64 -#define generation_n_new_large_words(__ptr__) REP_generation_n_new_large_words[__ptr__+OFFSET_generation_n_new_large_words] -#define OFFSET_generation_weak_ptr_list 112 -#define REP_generation_weak_ptr_list b64 -#define generation_weak_ptr_list(__ptr__) REP_generation_weak_ptr_list[__ptr__+OFFSET_generation_weak_ptr_list] -#define SIZEOF_CostCentreStack 96 -#define OFFSET_CostCentreStack_ccsID 0 -#define REP_CostCentreStack_ccsID b64 -#define CostCentreStack_ccsID(__ptr__) REP_CostCentreStack_ccsID[__ptr__+OFFSET_CostCentreStack_ccsID] -#define OFFSET_CostCentreStack_mem_alloc 72 -#define REP_CostCentreStack_mem_alloc b64 -#define CostCentreStack_mem_alloc(__ptr__) REP_CostCentreStack_mem_alloc[__ptr__+OFFSET_CostCentreStack_mem_alloc] -#define OFFSET_CostCentreStack_scc_count 48 -#define REP_CostCentreStack_scc_count b64 -#define CostCentreStack_scc_count(__ptr__) REP_CostCentreStack_scc_count[__ptr__+OFFSET_CostCentreStack_scc_count] -#define OFFSET_CostCentreStack_prevStack 16 -#define REP_CostCentreStack_prevStack b64 -#define CostCentreStack_prevStack(__ptr__) REP_CostCentreStack_prevStack[__ptr__+OFFSET_CostCentreStack_prevStack] -#define OFFSET_CostCentre_ccID 0 -#define REP_CostCentre_ccID b64 -#define CostCentre_ccID(__ptr__) REP_CostCentre_ccID[__ptr__+OFFSET_CostCentre_ccID] -#define OFFSET_CostCentre_link 56 -#define REP_CostCentre_link b64 -#define CostCentre_link(__ptr__) REP_CostCentre_link[__ptr__+OFFSET_CostCentre_link] -#define OFFSET_StgHeader_info 0 -#define REP_StgHeader_info b64 -#define StgHeader_info(__ptr__) REP_StgHeader_info[__ptr__+OFFSET_StgHeader_info] -#define OFFSET_StgHeader_ccs 8 -#define REP_StgHeader_ccs b64 -#define StgHeader_ccs(__ptr__) REP_StgHeader_ccs[__ptr__+OFFSET_StgHeader_ccs] -#define OFFSET_StgHeader_ldvw 16 -#define REP_StgHeader_ldvw b64 -#define StgHeader_ldvw(__ptr__) REP_StgHeader_ldvw[__ptr__+OFFSET_StgHeader_ldvw] -#define SIZEOF_StgSMPThunkHeader 8 -#define OFFSET_StgClosure_payload 0 -#define StgClosure_payload(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgClosure_payload + WDS(__ix__)] -#define OFFSET_StgEntCounter_allocs 48 -#define REP_StgEntCounter_allocs b64 -#define StgEntCounter_allocs(__ptr__) REP_StgEntCounter_allocs[__ptr__+OFFSET_StgEntCounter_allocs] -#define OFFSET_StgEntCounter_allocd 16 -#define REP_StgEntCounter_allocd b64 -#define StgEntCounter_allocd(__ptr__) REP_StgEntCounter_allocd[__ptr__+OFFSET_StgEntCounter_allocd] -#define OFFSET_StgEntCounter_registeredp 0 -#define REP_StgEntCounter_registeredp b64 -#define StgEntCounter_registeredp(__ptr__) REP_StgEntCounter_registeredp[__ptr__+OFFSET_StgEntCounter_registeredp] -#define OFFSET_StgEntCounter_link 56 -#define REP_StgEntCounter_link b64 -#define StgEntCounter_link(__ptr__) REP_StgEntCounter_link[__ptr__+OFFSET_StgEntCounter_link] -#define OFFSET_StgEntCounter_entry_count 40 -#define REP_StgEntCounter_entry_count b64 -#define StgEntCounter_entry_count(__ptr__) REP_StgEntCounter_entry_count[__ptr__+OFFSET_StgEntCounter_entry_count] -#define SIZEOF_StgUpdateFrame_NoHdr 8 -#define SIZEOF_StgUpdateFrame (SIZEOF_StgHeader+8) -#define SIZEOF_StgCatchFrame_NoHdr 16 -#define SIZEOF_StgCatchFrame (SIZEOF_StgHeader+16) -#define SIZEOF_StgStopFrame_NoHdr 0 -#define SIZEOF_StgStopFrame (SIZEOF_StgHeader+0) -#define SIZEOF_StgMutArrPtrs_NoHdr 16 -#define SIZEOF_StgMutArrPtrs (SIZEOF_StgHeader+16) -#define OFFSET_StgMutArrPtrs_ptrs 0 -#define REP_StgMutArrPtrs_ptrs b64 -#define StgMutArrPtrs_ptrs(__ptr__) REP_StgMutArrPtrs_ptrs[__ptr__+SIZEOF_StgHeader+OFFSET_StgMutArrPtrs_ptrs] -#define OFFSET_StgMutArrPtrs_size 8 -#define REP_StgMutArrPtrs_size b64 -#define StgMutArrPtrs_size(__ptr__) REP_StgMutArrPtrs_size[__ptr__+SIZEOF_StgHeader+OFFSET_StgMutArrPtrs_size] -#define SIZEOF_StgSmallMutArrPtrs_NoHdr 8 -#define SIZEOF_StgSmallMutArrPtrs (SIZEOF_StgHeader+8) -#define OFFSET_StgSmallMutArrPtrs_ptrs 0 -#define REP_StgSmallMutArrPtrs_ptrs b64 -#define StgSmallMutArrPtrs_ptrs(__ptr__) REP_StgSmallMutArrPtrs_ptrs[__ptr__+SIZEOF_StgHeader+OFFSET_StgSmallMutArrPtrs_ptrs] -#define SIZEOF_StgArrBytes_NoHdr 8 -#define SIZEOF_StgArrBytes (SIZEOF_StgHeader+8) -#define OFFSET_StgArrBytes_bytes 0 -#define REP_StgArrBytes_bytes b64 -#define StgArrBytes_bytes(__ptr__) REP_StgArrBytes_bytes[__ptr__+SIZEOF_StgHeader+OFFSET_StgArrBytes_bytes] -#define OFFSET_StgArrBytes_payload 8 -#define StgArrBytes_payload(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgArrBytes_payload + WDS(__ix__)] -#define OFFSET_StgTSO__link 0 -#define REP_StgTSO__link b64 -#define StgTSO__link(__ptr__) REP_StgTSO__link[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO__link] -#define OFFSET_StgTSO_global_link 8 -#define REP_StgTSO_global_link b64 -#define StgTSO_global_link(__ptr__) REP_StgTSO_global_link[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_global_link] -#define OFFSET_StgTSO_what_next 24 -#define REP_StgTSO_what_next b16 -#define StgTSO_what_next(__ptr__) REP_StgTSO_what_next[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_what_next] -#define OFFSET_StgTSO_why_blocked 26 -#define REP_StgTSO_why_blocked b16 -#define StgTSO_why_blocked(__ptr__) REP_StgTSO_why_blocked[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_why_blocked] -#define OFFSET_StgTSO_block_info 32 -#define REP_StgTSO_block_info b64 -#define StgTSO_block_info(__ptr__) REP_StgTSO_block_info[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_block_info] -#define OFFSET_StgTSO_blocked_exceptions 80 -#define REP_StgTSO_blocked_exceptions b64 -#define StgTSO_blocked_exceptions(__ptr__) REP_StgTSO_blocked_exceptions[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_blocked_exceptions] -#define OFFSET_StgTSO_id 40 -#define REP_StgTSO_id b32 -#define StgTSO_id(__ptr__) REP_StgTSO_id[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_id] -#define OFFSET_StgTSO_cap 64 -#define REP_StgTSO_cap b64 -#define StgTSO_cap(__ptr__) REP_StgTSO_cap[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_cap] -#define OFFSET_StgTSO_saved_errno 44 -#define REP_StgTSO_saved_errno b32 -#define StgTSO_saved_errno(__ptr__) REP_StgTSO_saved_errno[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_saved_errno] -#define OFFSET_StgTSO_trec 72 -#define REP_StgTSO_trec b64 -#define StgTSO_trec(__ptr__) REP_StgTSO_trec[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_trec] -#define OFFSET_StgTSO_flags 28 -#define REP_StgTSO_flags b32 -#define StgTSO_flags(__ptr__) REP_StgTSO_flags[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_flags] -#define OFFSET_StgTSO_dirty 48 -#define REP_StgTSO_dirty b32 -#define StgTSO_dirty(__ptr__) REP_StgTSO_dirty[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_dirty] -#define OFFSET_StgTSO_bq 88 -#define REP_StgTSO_bq b64 -#define StgTSO_bq(__ptr__) REP_StgTSO_bq[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_bq] -#define OFFSET_StgTSO_alloc_limit 96 -#define REP_StgTSO_alloc_limit b64 -#define StgTSO_alloc_limit(__ptr__) REP_StgTSO_alloc_limit[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_alloc_limit] -#define OFFSET_StgTSO_cccs 112 -#define REP_StgTSO_cccs b64 -#define StgTSO_cccs(__ptr__) REP_StgTSO_cccs[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_cccs] -#define OFFSET_StgTSO_stackobj 16 -#define REP_StgTSO_stackobj b64 -#define StgTSO_stackobj(__ptr__) REP_StgTSO_stackobj[__ptr__+SIZEOF_StgHeader+OFFSET_StgTSO_stackobj] -#define OFFSET_StgStack_sp 8 -#define REP_StgStack_sp b64 -#define StgStack_sp(__ptr__) REP_StgStack_sp[__ptr__+SIZEOF_StgHeader+OFFSET_StgStack_sp] -#define OFFSET_StgStack_stack 16 -#define OFFSET_StgStack_stack_size 0 -#define REP_StgStack_stack_size b32 -#define StgStack_stack_size(__ptr__) REP_StgStack_stack_size[__ptr__+SIZEOF_StgHeader+OFFSET_StgStack_stack_size] -#define OFFSET_StgStack_dirty 4 -#define REP_StgStack_dirty b32 -#define StgStack_dirty(__ptr__) REP_StgStack_dirty[__ptr__+SIZEOF_StgHeader+OFFSET_StgStack_dirty] -#define SIZEOF_StgTSOProfInfo 8 -#define OFFSET_StgUpdateFrame_updatee 0 -#define REP_StgUpdateFrame_updatee b64 -#define StgUpdateFrame_updatee(__ptr__) REP_StgUpdateFrame_updatee[__ptr__+SIZEOF_StgHeader+OFFSET_StgUpdateFrame_updatee] -#define OFFSET_StgCatchFrame_handler 8 -#define REP_StgCatchFrame_handler b64 -#define StgCatchFrame_handler(__ptr__) REP_StgCatchFrame_handler[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchFrame_handler] -#define OFFSET_StgCatchFrame_exceptions_blocked 0 -#define REP_StgCatchFrame_exceptions_blocked b64 -#define StgCatchFrame_exceptions_blocked(__ptr__) REP_StgCatchFrame_exceptions_blocked[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchFrame_exceptions_blocked] -#define SIZEOF_StgPAP_NoHdr 16 -#define SIZEOF_StgPAP (SIZEOF_StgHeader+16) -#define OFFSET_StgPAP_n_args 4 -#define REP_StgPAP_n_args b32 -#define StgPAP_n_args(__ptr__) REP_StgPAP_n_args[__ptr__+SIZEOF_StgHeader+OFFSET_StgPAP_n_args] -#define OFFSET_StgPAP_fun 8 -#define REP_StgPAP_fun gcptr -#define StgPAP_fun(__ptr__) REP_StgPAP_fun[__ptr__+SIZEOF_StgHeader+OFFSET_StgPAP_fun] -#define OFFSET_StgPAP_arity 0 -#define REP_StgPAP_arity b32 -#define StgPAP_arity(__ptr__) REP_StgPAP_arity[__ptr__+SIZEOF_StgHeader+OFFSET_StgPAP_arity] -#define OFFSET_StgPAP_payload 16 -#define StgPAP_payload(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgPAP_payload + WDS(__ix__)] -#define SIZEOF_StgAP_NoThunkHdr 16 -#define SIZEOF_StgAP_NoHdr 24 -#define SIZEOF_StgAP (SIZEOF_StgHeader+24) -#define OFFSET_StgAP_n_args 12 -#define REP_StgAP_n_args b32 -#define StgAP_n_args(__ptr__) REP_StgAP_n_args[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_n_args] -#define OFFSET_StgAP_fun 16 -#define REP_StgAP_fun gcptr -#define StgAP_fun(__ptr__) REP_StgAP_fun[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_fun] -#define OFFSET_StgAP_payload 24 -#define StgAP_payload(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_payload + WDS(__ix__)] -#define SIZEOF_StgAP_STACK_NoThunkHdr 16 -#define SIZEOF_StgAP_STACK_NoHdr 24 -#define SIZEOF_StgAP_STACK (SIZEOF_StgHeader+24) -#define OFFSET_StgAP_STACK_size 8 -#define REP_StgAP_STACK_size b64 -#define StgAP_STACK_size(__ptr__) REP_StgAP_STACK_size[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_STACK_size] -#define OFFSET_StgAP_STACK_fun 16 -#define REP_StgAP_STACK_fun gcptr -#define StgAP_STACK_fun(__ptr__) REP_StgAP_STACK_fun[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_STACK_fun] -#define OFFSET_StgAP_STACK_payload 24 -#define StgAP_STACK_payload(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgAP_STACK_payload + WDS(__ix__)] -#define SIZEOF_StgSelector_NoThunkHdr 8 -#define SIZEOF_StgSelector_NoHdr 16 -#define SIZEOF_StgSelector (SIZEOF_StgHeader+16) -#define OFFSET_StgInd_indirectee 0 -#define REP_StgInd_indirectee gcptr -#define StgInd_indirectee(__ptr__) REP_StgInd_indirectee[__ptr__+SIZEOF_StgHeader+OFFSET_StgInd_indirectee] -#define SIZEOF_StgMutVar_NoHdr 8 -#define SIZEOF_StgMutVar (SIZEOF_StgHeader+8) -#define OFFSET_StgMutVar_var 0 -#define REP_StgMutVar_var b64 -#define StgMutVar_var(__ptr__) REP_StgMutVar_var[__ptr__+SIZEOF_StgHeader+OFFSET_StgMutVar_var] -#define SIZEOF_StgAtomicallyFrame_NoHdr 16 -#define SIZEOF_StgAtomicallyFrame (SIZEOF_StgHeader+16) -#define OFFSET_StgAtomicallyFrame_code 0 -#define REP_StgAtomicallyFrame_code b64 -#define StgAtomicallyFrame_code(__ptr__) REP_StgAtomicallyFrame_code[__ptr__+SIZEOF_StgHeader+OFFSET_StgAtomicallyFrame_code] -#define OFFSET_StgAtomicallyFrame_result 8 -#define REP_StgAtomicallyFrame_result b64 -#define StgAtomicallyFrame_result(__ptr__) REP_StgAtomicallyFrame_result[__ptr__+SIZEOF_StgHeader+OFFSET_StgAtomicallyFrame_result] -#define OFFSET_StgTRecHeader_enclosing_trec 0 -#define REP_StgTRecHeader_enclosing_trec b64 -#define StgTRecHeader_enclosing_trec(__ptr__) REP_StgTRecHeader_enclosing_trec[__ptr__+SIZEOF_StgHeader+OFFSET_StgTRecHeader_enclosing_trec] -#define SIZEOF_StgCatchSTMFrame_NoHdr 16 -#define SIZEOF_StgCatchSTMFrame (SIZEOF_StgHeader+16) -#define OFFSET_StgCatchSTMFrame_handler 8 -#define REP_StgCatchSTMFrame_handler b64 -#define StgCatchSTMFrame_handler(__ptr__) REP_StgCatchSTMFrame_handler[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchSTMFrame_handler] -#define OFFSET_StgCatchSTMFrame_code 0 -#define REP_StgCatchSTMFrame_code b64 -#define StgCatchSTMFrame_code(__ptr__) REP_StgCatchSTMFrame_code[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchSTMFrame_code] -#define SIZEOF_StgCatchRetryFrame_NoHdr 24 -#define SIZEOF_StgCatchRetryFrame (SIZEOF_StgHeader+24) -#define OFFSET_StgCatchRetryFrame_running_alt_code 0 -#define REP_StgCatchRetryFrame_running_alt_code b64 -#define StgCatchRetryFrame_running_alt_code(__ptr__) REP_StgCatchRetryFrame_running_alt_code[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchRetryFrame_running_alt_code] -#define OFFSET_StgCatchRetryFrame_first_code 8 -#define REP_StgCatchRetryFrame_first_code b64 -#define StgCatchRetryFrame_first_code(__ptr__) REP_StgCatchRetryFrame_first_code[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchRetryFrame_first_code] -#define OFFSET_StgCatchRetryFrame_alt_code 16 -#define REP_StgCatchRetryFrame_alt_code b64 -#define StgCatchRetryFrame_alt_code(__ptr__) REP_StgCatchRetryFrame_alt_code[__ptr__+SIZEOF_StgHeader+OFFSET_StgCatchRetryFrame_alt_code] -#define OFFSET_StgTVarWatchQueue_closure 0 -#define REP_StgTVarWatchQueue_closure b64 -#define StgTVarWatchQueue_closure(__ptr__) REP_StgTVarWatchQueue_closure[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVarWatchQueue_closure] -#define OFFSET_StgTVarWatchQueue_next_queue_entry 8 -#define REP_StgTVarWatchQueue_next_queue_entry b64 -#define StgTVarWatchQueue_next_queue_entry(__ptr__) REP_StgTVarWatchQueue_next_queue_entry[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVarWatchQueue_next_queue_entry] -#define OFFSET_StgTVarWatchQueue_prev_queue_entry 16 -#define REP_StgTVarWatchQueue_prev_queue_entry b64 -#define StgTVarWatchQueue_prev_queue_entry(__ptr__) REP_StgTVarWatchQueue_prev_queue_entry[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVarWatchQueue_prev_queue_entry] -#define SIZEOF_StgTVar_NoHdr 24 -#define SIZEOF_StgTVar (SIZEOF_StgHeader+24) -#define OFFSET_StgTVar_current_value 0 -#define REP_StgTVar_current_value b64 -#define StgTVar_current_value(__ptr__) REP_StgTVar_current_value[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVar_current_value] -#define OFFSET_StgTVar_first_watch_queue_entry 8 -#define REP_StgTVar_first_watch_queue_entry b64 -#define StgTVar_first_watch_queue_entry(__ptr__) REP_StgTVar_first_watch_queue_entry[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVar_first_watch_queue_entry] -#define OFFSET_StgTVar_num_updates 16 -#define REP_StgTVar_num_updates b64 -#define StgTVar_num_updates(__ptr__) REP_StgTVar_num_updates[__ptr__+SIZEOF_StgHeader+OFFSET_StgTVar_num_updates] -#define SIZEOF_StgWeak_NoHdr 40 -#define SIZEOF_StgWeak (SIZEOF_StgHeader+40) -#define OFFSET_StgWeak_link 32 -#define REP_StgWeak_link b64 -#define StgWeak_link(__ptr__) REP_StgWeak_link[__ptr__+SIZEOF_StgHeader+OFFSET_StgWeak_link] -#define OFFSET_StgWeak_key 8 -#define REP_StgWeak_key b64 -#define StgWeak_key(__ptr__) REP_StgWeak_key[__ptr__+SIZEOF_StgHeader+OFFSET_StgWeak_key] -#define OFFSET_StgWeak_value 16 -#define REP_StgWeak_value b64 -#define StgWeak_value(__ptr__) REP_StgWeak_value[__ptr__+SIZEOF_StgHeader+OFFSET_StgWeak_value] -#define OFFSET_StgWeak_finalizer 24 -#define REP_StgWeak_finalizer b64 -#define StgWeak_finalizer(__ptr__) REP_StgWeak_finalizer[__ptr__+SIZEOF_StgHeader+OFFSET_StgWeak_finalizer] -#define OFFSET_StgWeak_cfinalizers 0 -#define REP_StgWeak_cfinalizers b64 -#define StgWeak_cfinalizers(__ptr__) REP_StgWeak_cfinalizers[__ptr__+SIZEOF_StgHeader+OFFSET_StgWeak_cfinalizers] -#define SIZEOF_StgCFinalizerList_NoHdr 40 -#define SIZEOF_StgCFinalizerList (SIZEOF_StgHeader+40) -#define OFFSET_StgCFinalizerList_link 0 -#define REP_StgCFinalizerList_link b64 -#define StgCFinalizerList_link(__ptr__) REP_StgCFinalizerList_link[__ptr__+SIZEOF_StgHeader+OFFSET_StgCFinalizerList_link] -#define OFFSET_StgCFinalizerList_fptr 8 -#define REP_StgCFinalizerList_fptr b64 -#define StgCFinalizerList_fptr(__ptr__) REP_StgCFinalizerList_fptr[__ptr__+SIZEOF_StgHeader+OFFSET_StgCFinalizerList_fptr] -#define OFFSET_StgCFinalizerList_ptr 16 -#define REP_StgCFinalizerList_ptr b64 -#define StgCFinalizerList_ptr(__ptr__) REP_StgCFinalizerList_ptr[__ptr__+SIZEOF_StgHeader+OFFSET_StgCFinalizerList_ptr] -#define OFFSET_StgCFinalizerList_eptr 24 -#define REP_StgCFinalizerList_eptr b64 -#define StgCFinalizerList_eptr(__ptr__) REP_StgCFinalizerList_eptr[__ptr__+SIZEOF_StgHeader+OFFSET_StgCFinalizerList_eptr] -#define OFFSET_StgCFinalizerList_flag 32 -#define REP_StgCFinalizerList_flag b64 -#define StgCFinalizerList_flag(__ptr__) REP_StgCFinalizerList_flag[__ptr__+SIZEOF_StgHeader+OFFSET_StgCFinalizerList_flag] -#define SIZEOF_StgMVar_NoHdr 24 -#define SIZEOF_StgMVar (SIZEOF_StgHeader+24) -#define OFFSET_StgMVar_head 0 -#define REP_StgMVar_head b64 -#define StgMVar_head(__ptr__) REP_StgMVar_head[__ptr__+SIZEOF_StgHeader+OFFSET_StgMVar_head] -#define OFFSET_StgMVar_tail 8 -#define REP_StgMVar_tail b64 -#define StgMVar_tail(__ptr__) REP_StgMVar_tail[__ptr__+SIZEOF_StgHeader+OFFSET_StgMVar_tail] -#define OFFSET_StgMVar_value 16 -#define REP_StgMVar_value b64 -#define StgMVar_value(__ptr__) REP_StgMVar_value[__ptr__+SIZEOF_StgHeader+OFFSET_StgMVar_value] -#define SIZEOF_StgMVarTSOQueue_NoHdr 16 -#define SIZEOF_StgMVarTSOQueue (SIZEOF_StgHeader+16) -#define OFFSET_StgMVarTSOQueue_link 0 -#define REP_StgMVarTSOQueue_link b64 -#define StgMVarTSOQueue_link(__ptr__) REP_StgMVarTSOQueue_link[__ptr__+SIZEOF_StgHeader+OFFSET_StgMVarTSOQueue_link] -#define OFFSET_StgMVarTSOQueue_tso 8 -#define REP_StgMVarTSOQueue_tso b64 -#define StgMVarTSOQueue_tso(__ptr__) REP_StgMVarTSOQueue_tso[__ptr__+SIZEOF_StgHeader+OFFSET_StgMVarTSOQueue_tso] -#define SIZEOF_StgBCO_NoHdr 32 -#define SIZEOF_StgBCO (SIZEOF_StgHeader+32) -#define OFFSET_StgBCO_instrs 0 -#define REP_StgBCO_instrs b64 -#define StgBCO_instrs(__ptr__) REP_StgBCO_instrs[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_instrs] -#define OFFSET_StgBCO_literals 8 -#define REP_StgBCO_literals b64 -#define StgBCO_literals(__ptr__) REP_StgBCO_literals[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_literals] -#define OFFSET_StgBCO_ptrs 16 -#define REP_StgBCO_ptrs b64 -#define StgBCO_ptrs(__ptr__) REP_StgBCO_ptrs[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_ptrs] -#define OFFSET_StgBCO_arity 24 -#define REP_StgBCO_arity b32 -#define StgBCO_arity(__ptr__) REP_StgBCO_arity[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_arity] -#define OFFSET_StgBCO_size 28 -#define REP_StgBCO_size b32 -#define StgBCO_size(__ptr__) REP_StgBCO_size[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_size] -#define OFFSET_StgBCO_bitmap 32 -#define StgBCO_bitmap(__ptr__,__ix__) W_[__ptr__+SIZEOF_StgHeader+OFFSET_StgBCO_bitmap + WDS(__ix__)] -#define SIZEOF_StgStableName_NoHdr 8 -#define SIZEOF_StgStableName (SIZEOF_StgHeader+8) -#define OFFSET_StgStableName_sn 0 -#define REP_StgStableName_sn b64 -#define StgStableName_sn(__ptr__) REP_StgStableName_sn[__ptr__+SIZEOF_StgHeader+OFFSET_StgStableName_sn] -#define SIZEOF_StgBlockingQueue_NoHdr 32 -#define SIZEOF_StgBlockingQueue (SIZEOF_StgHeader+32) -#define OFFSET_StgBlockingQueue_bh 8 -#define REP_StgBlockingQueue_bh b64 -#define StgBlockingQueue_bh(__ptr__) REP_StgBlockingQueue_bh[__ptr__+SIZEOF_StgHeader+OFFSET_StgBlockingQueue_bh] -#define OFFSET_StgBlockingQueue_owner 16 -#define REP_StgBlockingQueue_owner b64 -#define StgBlockingQueue_owner(__ptr__) REP_StgBlockingQueue_owner[__ptr__+SIZEOF_StgHeader+OFFSET_StgBlockingQueue_owner] -#define OFFSET_StgBlockingQueue_queue 24 -#define REP_StgBlockingQueue_queue b64 -#define StgBlockingQueue_queue(__ptr__) REP_StgBlockingQueue_queue[__ptr__+SIZEOF_StgHeader+OFFSET_StgBlockingQueue_queue] -#define OFFSET_StgBlockingQueue_link 0 -#define REP_StgBlockingQueue_link b64 -#define StgBlockingQueue_link(__ptr__) REP_StgBlockingQueue_link[__ptr__+SIZEOF_StgHeader+OFFSET_StgBlockingQueue_link] -#define SIZEOF_MessageBlackHole_NoHdr 24 -#define SIZEOF_MessageBlackHole (SIZEOF_StgHeader+24) -#define OFFSET_MessageBlackHole_link 0 -#define REP_MessageBlackHole_link b64 -#define MessageBlackHole_link(__ptr__) REP_MessageBlackHole_link[__ptr__+SIZEOF_StgHeader+OFFSET_MessageBlackHole_link] -#define OFFSET_MessageBlackHole_tso 8 -#define REP_MessageBlackHole_tso b64 -#define MessageBlackHole_tso(__ptr__) REP_MessageBlackHole_tso[__ptr__+SIZEOF_StgHeader+OFFSET_MessageBlackHole_tso] -#define OFFSET_MessageBlackHole_bh 16 -#define REP_MessageBlackHole_bh b64 -#define MessageBlackHole_bh(__ptr__) REP_MessageBlackHole_bh[__ptr__+SIZEOF_StgHeader+OFFSET_MessageBlackHole_bh] -#define SIZEOF_StgCompactNFData_NoHdr 64 -#define SIZEOF_StgCompactNFData (SIZEOF_StgHeader+64) -#define OFFSET_StgCompactNFData_totalW 0 -#define REP_StgCompactNFData_totalW b64 -#define StgCompactNFData_totalW(__ptr__) REP_StgCompactNFData_totalW[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_totalW] -#define OFFSET_StgCompactNFData_autoBlockW 8 -#define REP_StgCompactNFData_autoBlockW b64 -#define StgCompactNFData_autoBlockW(__ptr__) REP_StgCompactNFData_autoBlockW[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_autoBlockW] -#define OFFSET_StgCompactNFData_nursery 32 -#define REP_StgCompactNFData_nursery b64 -#define StgCompactNFData_nursery(__ptr__) REP_StgCompactNFData_nursery[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_nursery] -#define OFFSET_StgCompactNFData_last 40 -#define REP_StgCompactNFData_last b64 -#define StgCompactNFData_last(__ptr__) REP_StgCompactNFData_last[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_last] -#define OFFSET_StgCompactNFData_hp 16 -#define REP_StgCompactNFData_hp b64 -#define StgCompactNFData_hp(__ptr__) REP_StgCompactNFData_hp[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_hp] -#define OFFSET_StgCompactNFData_hpLim 24 -#define REP_StgCompactNFData_hpLim b64 -#define StgCompactNFData_hpLim(__ptr__) REP_StgCompactNFData_hpLim[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_hpLim] -#define OFFSET_StgCompactNFData_hash 48 -#define REP_StgCompactNFData_hash b64 -#define StgCompactNFData_hash(__ptr__) REP_StgCompactNFData_hash[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_hash] -#define OFFSET_StgCompactNFData_result 56 -#define REP_StgCompactNFData_result b64 -#define StgCompactNFData_result(__ptr__) REP_StgCompactNFData_result[__ptr__+SIZEOF_StgHeader+OFFSET_StgCompactNFData_result] -#define SIZEOF_StgCompactNFDataBlock 24 -#define OFFSET_StgCompactNFDataBlock_self 0 -#define REP_StgCompactNFDataBlock_self b64 -#define StgCompactNFDataBlock_self(__ptr__) REP_StgCompactNFDataBlock_self[__ptr__+OFFSET_StgCompactNFDataBlock_self] -#define OFFSET_StgCompactNFDataBlock_owner 8 -#define REP_StgCompactNFDataBlock_owner b64 -#define StgCompactNFDataBlock_owner(__ptr__) REP_StgCompactNFDataBlock_owner[__ptr__+OFFSET_StgCompactNFDataBlock_owner] -#define OFFSET_StgCompactNFDataBlock_next 16 -#define REP_StgCompactNFDataBlock_next b64 -#define StgCompactNFDataBlock_next(__ptr__) REP_StgCompactNFDataBlock_next[__ptr__+OFFSET_StgCompactNFDataBlock_next] -#define OFFSET_RtsFlags_ProfFlags_showCCSOnException 269 -#define REP_RtsFlags_ProfFlags_showCCSOnException b8 -#define RtsFlags_ProfFlags_showCCSOnException(__ptr__) REP_RtsFlags_ProfFlags_showCCSOnException[__ptr__+OFFSET_RtsFlags_ProfFlags_showCCSOnException] -#define OFFSET_RtsFlags_DebugFlags_apply 210 -#define REP_RtsFlags_DebugFlags_apply b8 -#define RtsFlags_DebugFlags_apply(__ptr__) REP_RtsFlags_DebugFlags_apply[__ptr__+OFFSET_RtsFlags_DebugFlags_apply] -#define OFFSET_RtsFlags_DebugFlags_sanity 206 -#define REP_RtsFlags_DebugFlags_sanity b8 -#define RtsFlags_DebugFlags_sanity(__ptr__) REP_RtsFlags_DebugFlags_sanity[__ptr__+OFFSET_RtsFlags_DebugFlags_sanity] -#define OFFSET_RtsFlags_DebugFlags_weak 202 -#define REP_RtsFlags_DebugFlags_weak b8 -#define RtsFlags_DebugFlags_weak(__ptr__) REP_RtsFlags_DebugFlags_weak[__ptr__+OFFSET_RtsFlags_DebugFlags_weak] -#define OFFSET_RtsFlags_GcFlags_initialStkSize 16 -#define REP_RtsFlags_GcFlags_initialStkSize b32 -#define RtsFlags_GcFlags_initialStkSize(__ptr__) REP_RtsFlags_GcFlags_initialStkSize[__ptr__+OFFSET_RtsFlags_GcFlags_initialStkSize] -#define OFFSET_RtsFlags_MiscFlags_tickInterval 176 -#define REP_RtsFlags_MiscFlags_tickInterval b64 -#define RtsFlags_MiscFlags_tickInterval(__ptr__) REP_RtsFlags_MiscFlags_tickInterval[__ptr__+OFFSET_RtsFlags_MiscFlags_tickInterval] -#define SIZEOF_StgFunInfoExtraFwd 32 -#define OFFSET_StgFunInfoExtraFwd_slow_apply 24 -#define REP_StgFunInfoExtraFwd_slow_apply b64 -#define StgFunInfoExtraFwd_slow_apply(__ptr__) REP_StgFunInfoExtraFwd_slow_apply[__ptr__+OFFSET_StgFunInfoExtraFwd_slow_apply] -#define OFFSET_StgFunInfoExtraFwd_fun_type 0 -#define REP_StgFunInfoExtraFwd_fun_type b32 -#define StgFunInfoExtraFwd_fun_type(__ptr__) REP_StgFunInfoExtraFwd_fun_type[__ptr__+OFFSET_StgFunInfoExtraFwd_fun_type] -#define OFFSET_StgFunInfoExtraFwd_arity 4 -#define REP_StgFunInfoExtraFwd_arity b32 -#define StgFunInfoExtraFwd_arity(__ptr__) REP_StgFunInfoExtraFwd_arity[__ptr__+OFFSET_StgFunInfoExtraFwd_arity] -#define OFFSET_StgFunInfoExtraFwd_bitmap 16 -#define REP_StgFunInfoExtraFwd_bitmap b64 -#define StgFunInfoExtraFwd_bitmap(__ptr__) REP_StgFunInfoExtraFwd_bitmap[__ptr__+OFFSET_StgFunInfoExtraFwd_bitmap] -#define SIZEOF_StgFunInfoExtraRev 24 -#define OFFSET_StgFunInfoExtraRev_slow_apply_offset 0 -#define REP_StgFunInfoExtraRev_slow_apply_offset b32 -#define StgFunInfoExtraRev_slow_apply_offset(__ptr__) REP_StgFunInfoExtraRev_slow_apply_offset[__ptr__+OFFSET_StgFunInfoExtraRev_slow_apply_offset] -#define OFFSET_StgFunInfoExtraRev_fun_type 16 -#define REP_StgFunInfoExtraRev_fun_type b32 -#define StgFunInfoExtraRev_fun_type(__ptr__) REP_StgFunInfoExtraRev_fun_type[__ptr__+OFFSET_StgFunInfoExtraRev_fun_type] -#define OFFSET_StgFunInfoExtraRev_arity 20 -#define REP_StgFunInfoExtraRev_arity b32 -#define StgFunInfoExtraRev_arity(__ptr__) REP_StgFunInfoExtraRev_arity[__ptr__+OFFSET_StgFunInfoExtraRev_arity] -#define OFFSET_StgFunInfoExtraRev_bitmap 8 -#define REP_StgFunInfoExtraRev_bitmap b64 -#define StgFunInfoExtraRev_bitmap(__ptr__) REP_StgFunInfoExtraRev_bitmap[__ptr__+OFFSET_StgFunInfoExtraRev_bitmap] -#define OFFSET_StgFunInfoExtraRev_bitmap_offset 8 -#define REP_StgFunInfoExtraRev_bitmap_offset b32 -#define StgFunInfoExtraRev_bitmap_offset(__ptr__) REP_StgFunInfoExtraRev_bitmap_offset[__ptr__+OFFSET_StgFunInfoExtraRev_bitmap_offset] -#define OFFSET_StgLargeBitmap_size 0 -#define REP_StgLargeBitmap_size b64 -#define StgLargeBitmap_size(__ptr__) REP_StgLargeBitmap_size[__ptr__+OFFSET_StgLargeBitmap_size] -#define OFFSET_StgLargeBitmap_bitmap 8 -#define SIZEOF_snEntry 24 -#define OFFSET_snEntry_sn_obj 16 -#define REP_snEntry_sn_obj b64 -#define snEntry_sn_obj(__ptr__) REP_snEntry_sn_obj[__ptr__+OFFSET_snEntry_sn_obj] -#define OFFSET_snEntry_addr 0 -#define REP_snEntry_addr b64 -#define snEntry_addr(__ptr__) REP_snEntry_addr[__ptr__+OFFSET_snEntry_addr] -#define SIZEOF_spEntry 8 -#define OFFSET_spEntry_addr 0 -#define REP_spEntry_addr b64 -#define spEntry_addr(__ptr__) REP_spEntry_addr[__ptr__+OFFSET_spEntry_addr] diff --git a/ghc-lib/generated/ghcautoconf.h b/ghc-lib/generated/ghcautoconf.h --- a/ghc-lib/generated/ghcautoconf.h +++ b/ghc-lib/generated/ghcautoconf.h @@ -72,7 +72,12 @@ /* Define to 1 if __thread is supported */ #define CC_SUPPORTS_TLS 1 -/* Define to 1 if using 'alloca.c'. */ +/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP + systems. This function is required for `alloca.c' support on those systems. + */ +/* #undef CRAY_STACKSEG_END */ + +/* Define to 1 if using `alloca.c'. */ /* #undef C_ALLOCA */ /* Define to 1 if your processor stores words of floats with the most @@ -82,10 +87,11 @@ /* Has visibility hidden */ #define HAS_VISIBILITY_HIDDEN 1 -/* Define to 1 if you have 'alloca', as a function or macro. */ +/* Define to 1 if you have `alloca', as a function or macro. */ #define HAVE_ALLOCA 1 -/* Define to 1 if works. */ +/* Define to 1 if you have and it should be used (not on Ultrix). + */ #define HAVE_ALLOCA_H 1 /* Define to 1 if you have the header file. */ @@ -191,12 +197,12 @@ /* Define to 1 if the system has the type `long long'. */ #define HAVE_LONG_LONG 1 +/* Define to 1 if you have the header file. */ +#define HAVE_MEMORY_H 1 + /* Define to 1 if you have the mingwex library. */ /* #undef HAVE_MINGWEX */ -/* Define to 1 if you have the header file. */ -/* #undef HAVE_MINIX_CONFIG_H */ - /* Define to 1 if you have the header file. */ #define HAVE_NLIST_H 1 @@ -239,9 +245,6 @@ /* Define to 1 if you have the header file. */ #define HAVE_STDINT_H 1 -/* Define to 1 if you have the header file. */ -#define HAVE_STDIO_H 1 - /* Define to 1 if you have the header file. */ #define HAVE_STDLIB_H 1 @@ -326,9 +329,6 @@ /* Define to 1 if you have the header file. */ /* #undef HAVE_VFORK_H */ -/* Define to 1 if you have the header file. */ -#define HAVE_WCHAR_H 1 - /* Define to 1 if you have the header file. */ /* #undef HAVE_WINDOWS_H */ @@ -443,13 +443,10 @@ STACK_DIRECTION = 0 => direction of growth unknown */ /* #undef STACK_DIRECTION */ -/* Define to 1 if all of the C90 standard headers exist (not just the ones - required in a freestanding environment). This macro is provided for - backward compatibility; new code need not use it. */ +/* Define to 1 if you have the ANSI C header files. */ #define STDC_HEADERS 1 -/* Define to 1 if you can safely include both and . This - macro is obsolete. */ +/* Define to 1 if you can safely include both and . */ #define TIME_WITH_SYS_TIME 1 /* Enable single heap address space support */ @@ -462,87 +459,21 @@ #ifndef _ALL_SOURCE # define _ALL_SOURCE 1 #endif -/* Enable general extensions on macOS. */ -#ifndef _DARWIN_C_SOURCE -# define _DARWIN_C_SOURCE 1 -#endif -/* Enable general extensions on Solaris. */ -#ifndef __EXTENSIONS__ -# define __EXTENSIONS__ 1 -#endif /* Enable GNU extensions on systems that have them. */ #ifndef _GNU_SOURCE # define _GNU_SOURCE 1 #endif -/* Enable X/Open compliant socket functions that do not require linking - with -lxnet on HP-UX 11.11. */ -#ifndef _HPUX_ALT_XOPEN_SOCKET_API -# define _HPUX_ALT_XOPEN_SOCKET_API 1 -#endif -/* Identify the host operating system as Minix. - This macro does not affect the system headers' behavior. - A future release of Autoconf may stop defining this macro. */ -#ifndef _MINIX -/* # undef _MINIX */ -#endif -/* Enable general extensions on NetBSD. - Enable NetBSD compatibility extensions on Minix. */ -#ifndef _NETBSD_SOURCE -# define _NETBSD_SOURCE 1 -#endif -/* Enable OpenBSD compatibility extensions on NetBSD. - Oddly enough, this does nothing on OpenBSD. */ -#ifndef _OPENBSD_SOURCE -# define _OPENBSD_SOURCE 1 -#endif -/* Define to 1 if needed for POSIX-compatible behavior. */ -#ifndef _POSIX_SOURCE -/* # undef _POSIX_SOURCE */ -#endif -/* Define to 2 if needed for POSIX-compatible behavior. */ -#ifndef _POSIX_1_SOURCE -/* # undef _POSIX_1_SOURCE */ -#endif -/* Enable POSIX-compatible threading on Solaris. */ +/* Enable threading extensions on Solaris. */ #ifndef _POSIX_PTHREAD_SEMANTICS # define _POSIX_PTHREAD_SEMANTICS 1 #endif -/* Enable extensions specified by ISO/IEC TS 18661-5:2014. */ -#ifndef __STDC_WANT_IEC_60559_ATTRIBS_EXT__ -# define __STDC_WANT_IEC_60559_ATTRIBS_EXT__ 1 -#endif -/* Enable extensions specified by ISO/IEC TS 18661-1:2014. */ -#ifndef __STDC_WANT_IEC_60559_BFP_EXT__ -# define __STDC_WANT_IEC_60559_BFP_EXT__ 1 -#endif -/* Enable extensions specified by ISO/IEC TS 18661-2:2015. */ -#ifndef __STDC_WANT_IEC_60559_DFP_EXT__ -# define __STDC_WANT_IEC_60559_DFP_EXT__ 1 -#endif -/* Enable extensions specified by ISO/IEC TS 18661-4:2015. */ -#ifndef __STDC_WANT_IEC_60559_FUNCS_EXT__ -# define __STDC_WANT_IEC_60559_FUNCS_EXT__ 1 -#endif -/* Enable extensions specified by ISO/IEC TS 18661-3:2015. */ -#ifndef __STDC_WANT_IEC_60559_TYPES_EXT__ -# define __STDC_WANT_IEC_60559_TYPES_EXT__ 1 -#endif -/* Enable extensions specified by ISO/IEC TR 24731-2:2010. */ -#ifndef __STDC_WANT_LIB_EXT2__ -# define __STDC_WANT_LIB_EXT2__ 1 -#endif -/* Enable extensions specified by ISO/IEC 24747:2009. */ -#ifndef __STDC_WANT_MATH_SPEC_FUNCS__ -# define __STDC_WANT_MATH_SPEC_FUNCS__ 1 -#endif /* Enable extensions on HP NonStop. */ #ifndef _TANDEM_SOURCE # define _TANDEM_SOURCE 1 #endif -/* Enable X/Open extensions. Define to 500 only if necessary - to make mbstate_t available. */ -#ifndef _XOPEN_SOURCE -/* # undef _XOPEN_SOURCE */ +/* Enable general extensions on Solaris. */ +#ifndef __EXTENSIONS__ +# define __EXTENSIONS__ 1 #endif @@ -561,12 +492,27 @@ # endif #endif +/* Enable large inode numbers on Mac OS X 10.5. */ +#ifndef _DARWIN_USE_64_BIT_INODE +# define _DARWIN_USE_64_BIT_INODE 1 +#endif + /* Number of bits in a file offset, on hosts where this is settable. */ /* #undef _FILE_OFFSET_BITS */ /* Define for large files, on AIX-style hosts. */ /* #undef _LARGE_FILES */ +/* Define to 1 if on MINIX. */ +/* #undef _MINIX */ + +/* Define to 2 if the system does not provide POSIX.1 features except with + this defined. */ +/* #undef _POSIX_1_SOURCE */ + +/* Define to 1 if you need to in order for `stat' and other things to work. */ +/* #undef _POSIX_SOURCE */ + /* ARM pre v6 */ /* #undef arm_HOST_ARCH_PRE_ARMv6 */ @@ -576,7 +522,7 @@ /* Define to empty if `const' does not conform to ANSI C. */ /* #undef const */ -/* Define as a signed integer type capable of holding a process identifier. */ +/* Define to `int' if does not define. */ /* #undef pid_t */ /* The supported LLVM version number */ diff --git a/ghc-lib/generated/ghcversion.h b/ghc-lib/generated/ghcversion.h new file mode 100644 --- /dev/null +++ b/ghc-lib/generated/ghcversion.h @@ -0,0 +1,18 @@ +#ifndef __GHCVERSION_H__ +#define __GHCVERSION_H__ + +#ifndef __GLASGOW_HASKELL__ +# define __GLASGOW_HASKELL__ 808 +#endif + +#define __GLASGOW_HASKELL_PATCHLEVEL1__ 2 + +#define MIN_VERSION_GLASGOW_HASKELL(ma,mi,pl1,pl2) (\ + ((ma)*100+(mi)) < __GLASGOW_HASKELL__ || \ + ((ma)*100+(mi)) == __GLASGOW_HASKELL__ \ + && (pl1) < __GLASGOW_HASKELL_PATCHLEVEL1__ || \ + ((ma)*100+(mi)) == __GLASGOW_HASKELL__ \ + && (pl1) == __GLASGOW_HASKELL_PATCHLEVEL1__ \ + && (pl2) <= __GLASGOW_HASKELL_PATCHLEVEL2__ ) + +#endif /* __GHCVERSION_H__ */ diff --git a/ghc-lib/stage0/compiler/build/Config.hs b/ghc-lib/stage0/compiler/build/Config.hs --- a/ghc-lib/stage0/compiler/build/Config.hs +++ b/ghc-lib/stage0/compiler/build/Config.hs @@ -19,15 +19,15 @@ cProjectName :: String cProjectName = "The Glorious Glasgow Haskell Compilation System" cProjectGitCommitId :: String -cProjectGitCommitId = "9c787d4d24f2b515934c8503ee2bbd7cfac4da20" +cProjectGitCommitId = "86f4a56c8888d249194c38799eaec9484222fa47" cProjectVersion :: String -cProjectVersion = "8.8.1" +cProjectVersion = "8.8.2" cProjectVersionInt :: String cProjectVersionInt = "808" cProjectPatchLevel :: String -cProjectPatchLevel = "1" +cProjectPatchLevel = "2" cProjectPatchLevel1 :: String -cProjectPatchLevel1 = "1" +cProjectPatchLevel1 = "2" cProjectPatchLevel2 :: String cProjectPatchLevel2 = "" cBooterVersion :: String diff --git a/ghc-lib/stage0/compiler/build/Fingerprint.hs b/ghc-lib/stage0/compiler/build/Fingerprint.hs --- a/ghc-lib/stage0/compiler/build/Fingerprint.hs +++ b/ghc-lib/stage0/compiler/build/Fingerprint.hs @@ -23,7 +23,7 @@ ) where -#include "GhclibHsVersions.h" +#include "HsVersions.h" import GhcPrelude diff --git a/ghc-lib/stage0/compiler/build/Parser.hs b/ghc-lib/stage0/compiler/build/Parser.hs --- a/ghc-lib/stage0/compiler/build/Parser.hs +++ b/ghc-lib/stage0/compiler/build/Parser.hs @@ -12514,7 +12514,7 @@ {-# LINE 1 "templates/GenericTemplate.hs" #-} {-# LINE 1 "" #-} {-# LINE 18 "" #-} -{-# LINE 1 "/Users/shayne/.stack/programs/x86_64-osx/ghc-8.4.3/lib/ghc-8.4.3/include/ghcversion.h" #-} +{-# LINE 1 "/Users/shaynefletcher/.stack/programs/x86_64-osx/ghc-8.4.3/lib/ghc-8.4.3/include/ghcversion.h" #-} @@ -12532,7 +12532,7 @@ {-# LINE 19 "" #-} -{-# LINE 1 "/var/folders/rj/q93vlym52875_k7nwz_c3wth0000gn/T/ghc94308_0/ghc_2.h" #-} +{-# LINE 1 "/var/folders/kc/bjk2hzwx6bv07jz_s80wjh7w0000gn/T/ghc6627_0/ghc_2.h" #-} diff --git a/libraries/ghc-heap/GHC/Exts/Heap/Closures.hs b/libraries/ghc-heap/GHC/Exts/Heap/Closures.hs --- a/libraries/ghc-heap/GHC/Exts/Heap/Closures.hs +++ b/libraries/ghc-heap/GHC/Exts/Heap/Closures.hs @@ -44,10 +44,13 @@ ------------------------------------------------------------------------ -- Boxes -foreign import prim "Ghclib_aToWordzh" aToWord# :: Any -> Word# +aToWord# :: Any -> Word# +aToWord# _ = 0## -foreign import prim "Ghclib_reallyUnsafePtrEqualityUpToTag" - reallyUnsafePtrEqualityUpToTag# :: Any -> Any -> Int# + +reallyUnsafePtrEqualityUpToTag# :: Any -> Any -> Int# +reallyUnsafePtrEqualityUpToTag# _ _ = 0# + -- | An arbitrary Haskell value in a safe Box. The point is that even -- unevaluated thunks can safely be moved around inside the Box, and when diff --git a/libraries/ghc-heap/GHC/Exts/Heap/InfoTable.hsc b/libraries/ghc-heap/GHC/Exts/Heap/InfoTable.hsc --- a/libraries/ghc-heap/GHC/Exts/Heap/InfoTable.hsc +++ b/libraries/ghc-heap/GHC/Exts/Heap/InfoTable.hsc @@ -1,4 +1,3 @@ -{-# LANGUAGE NoMonoLocalBinds #-} module GHC.Exts.Heap.InfoTable ( module GHC.Exts.Heap.InfoTable.Types , itblSize diff --git a/libraries/ghc-heap/GHC/Exts/Heap/InfoTableProf.hsc b/libraries/ghc-heap/GHC/Exts/Heap/InfoTableProf.hsc --- a/libraries/ghc-heap/GHC/Exts/Heap/InfoTableProf.hsc +++ b/libraries/ghc-heap/GHC/Exts/Heap/InfoTableProf.hsc @@ -1,4 +1,3 @@ -{-# LANGUAGE NoMonoLocalBinds #-} module GHC.Exts.Heap.InfoTableProf ( module GHC.Exts.Heap.InfoTable.Types , itblSize diff --git a/libraries/ghc-heap/cbits/HeapPrim.cmm b/libraries/ghc-heap/cbits/HeapPrim.cmm deleted file mode 100644 --- a/libraries/ghc-heap/cbits/HeapPrim.cmm +++ /dev/null @@ -1,13 +0,0 @@ -#include "Cmm.h" - -Ghclib_aToWordzh (P_ clos) -{ - return (clos); -} - -Ghclib_reallyUnsafePtrEqualityUpToTag (W_ clos1, W_ clos2) -{ - clos1 = UNTAG(clos1); - clos2 = UNTAG(clos2); - return (clos1 == clos2); -}