content: {-# LANGUAGE OverloadedStrings #-}
  
  -- | JS symbol generation
  module GHC.StgToJS.Symbols where
  
  import GHC.Prelude
  
  import GHC.JS.JStg.Syntax
  import GHC.JS.Ident
  
  import GHC.Data.FastString
  import GHC.Unit.Module
  import GHC.Utils.Word64 (intToWord64)
  import Data.ByteString (ByteString)
  import Data.Word (Word64)
  import qualified Data.ByteString.Char8   as BSC
  import qualified Data.ByteString.Builder as BSB
  import qualified Data.ByteString.Lazy    as BSL
  
  import Data.Array
  import Data.Semigroup ((<>))
  
  -- | Hexadecimal representation of an int
  --
  -- Used for the sub indices.
  intBS :: Int -> ByteString
  intBS = word64BS . intToWord64
  
  -- | Hexadecimal representation of a 64-bit word
  --
  -- Used for uniques. We could use base-62 as GHC usually does but this is likely
  -- faster.
  word64BS :: Word64 -> ByteString
  word64BS = BSL.toStrict . BSB.toLazyByteString . BSB.word64Hex
  
  -- | Return z-encoded unit:module
  unitModuleStringZ :: Module -> ByteString
  unitModuleStringZ mod = mconcat
    [ fastZStringToByteString (zEncodeFS (unitIdFS (moduleUnitId mod)))
    , BSC.pack "ZC" -- z-encoding for ":"
    , fastZStringToByteString (zEncodeFS (moduleNameFS (moduleName mod)))
    ]
  
  -- | the global linkable unit of a module exports this symbol, depend on it to
  --   include that unit (used for cost centres)
  moduleGlobalSymbol :: Module -> FastString
  moduleGlobalSymbol m = mkFastStringByteString $ mconcat
    [ hdB
    , unitModuleStringZ m
    , BSC.pack "_<global>"
    ]
  
  moduleExportsSymbol :: Module -> FastString
  moduleExportsSymbol m = mkFastStringByteString $ mconcat
    [ hdB
    , unitModuleStringZ m
    , BSC.pack "_<exports>"
    ]
  
  -- | Make JS symbol corresponding to the given Haskell symbol in the given
  -- module
  mkJsSymbolBS :: Bool -> Module -> FastString -> ByteString
  mkJsSymbolBS exported mod s = mconcat
    [ if exported then hdB else hddB
    , unitModuleStringZ mod
    , BSC.pack "zi" -- z-encoding of "."
    , fastZStringToByteString (zEncodeFS s)
    ]
  
  -- | Make JS symbol corresponding to the given Haskell symbol in the given
  -- module
  mkJsSymbol :: Bool -> Module -> FastString -> FastString
  mkJsSymbol exported mod s = mkFastStringByteString (mkJsSymbolBS exported mod s)
  
  -- | Make JS symbol for given module and unique.
  mkFreshJsSymbol :: Module -> Int -> FastString
  mkFreshJsSymbol mod i = mkFastStringByteString $ mconcat
    [ hddB
    , unitModuleStringZ mod
    , BSC.pack "_"
    , intBS i
    ]
  
  -- | Make symbol "h$XYZ" or "h$$XYZ"
  mkRawSymbol :: Bool -> FastString -> FastString
  mkRawSymbol exported fs
    | exported  = mkFastStringByteString $ mconcat [ hdB,  bytesFS fs ]
    | otherwise = mkFastStringByteString $ mconcat [ hddB, bytesFS fs ]
  
  -- | "h$$" constant string
  hddB :: ByteString
  hddB = BSC.pack "h$$"
  
  -- | "h$" constant string
  hdB :: ByteString
  hdB = BSC.take 2 hddB
  
  hd :: JStgExpr
  hd = global hdStr
  
  hdStr :: FastString
  hdStr = mkFastStringByteString hdB
  
  hdlB :: ByteString
  hdlB = BSC.pack "h$l"
  
  ----------------------------------------- Runtime -------------------------------
  hdApply :: JStgExpr
  hdApply = global hdApplyStr
  
  hdApplyStr :: FastString
  hdApplyStr = fsLit "h$apply"
  
  hdMoveRegs2 :: FastString
  hdMoveRegs2 = fsLit "h$moveRegs2"
  
  hdPapGen :: JStgExpr
  hdPapGen = global hdPapGenStr
  
  hdPapGenStr :: FastString
  hdPapGenStr = fsLit "h$pap_gen"
  
  hdSetReg :: JStgExpr
  hdSetReg = global hdSetRegStr
  
  hdSetRegStr :: FastString
  hdSetRegStr = fsLit "h$setReg"
  
  hdGetReg :: JStgExpr
  hdGetReg = global hdGetRegStr
  
  hdGetRegStr :: FastString
  hdGetRegStr = fsLit "h$getReg"
  
  hdResetRegisters :: Ident
  hdResetRegisters = name "h$resetRegisters"
  
  hdResetResultVars :: Ident
  hdResetResultVars = name "h$resetResultVars"
  
  hdInitClosure :: FastString
  hdInitClosure = fsLit "h$init_closure"
  
  hdRegs :: JStgExpr
  hdRegs = global (identFS hdRegsStr)
  
  hdRegsStr :: Ident
  hdRegsStr = name "h$regs"
  
  hdReturn :: JStgExpr
  hdReturn = global (identFS hdReturnStr)
  
  hdReturnStr :: Ident
  hdReturnStr = name "h$return"
  
  hdStack :: JStgExpr
  hdStack = global (identFS hdStackStr)
  
  hdStackStr :: Ident
  hdStackStr = name "h$stack"
  
  hdStackPtr :: JStgExpr
  hdStackPtr = global (identFS hdStackPtrStr)
  
  hdStackPtrStr :: Ident
  hdStackPtrStr = name "h$sp"
  
  hdBlackHoleTrap :: JStgExpr
  hdBlackHoleTrap = global (identFS hdBlackHoleTrapStr)
  
  hdBlackHoleTrapStr :: Ident
  hdBlackHoleTrapStr = name "h$blackholeTrap"
  
  hdBlockOnBlackHoleStr :: FastString
  hdBlockOnBlackHoleStr = "h$blockOnBlackhole"
  
  hdBlackHoleLNE :: JStgExpr
  hdBlackHoleLNE = global (identFS hdBlackHoleLNEStr)
  
  hdBlackHoleLNEStr :: Ident
  hdBlackHoleLNEStr = name "h$bh_lne"
  
  hdClosureTypeName :: JStgExpr
  hdClosureTypeName = global (identFS hdClosureTypeNameStr)
  
  hdClosureTypeNameStr :: Ident
  hdClosureTypeNameStr = name "h$closureTypeName"
  
  hdBh :: JStgExpr
  hdBh = global hdBhStr
  
  hdBhStr :: FastString
  hdBhStr = fsLit "h$bh"
  
  hdBlackHole :: JStgExpr
  hdBlackHole = global (identFS hdBlackHoleStr)
  
  hdBlackHoleStr :: Ident
  hdBlackHoleStr = name "h$blackhole"
  
  hdUpdFrame :: JStgExpr
  hdUpdFrame = global (identFS hdUpdFrameStr)
  
  hdUpdFrameStr :: Ident
  hdUpdFrameStr = name $ fsLit "h$upd_frame"
  
  hdCSel :: JStgExpr
  hdCSel = global hdCSelStr
  
  hdCSelStr :: FastString
  hdCSelStr = "h$c_sel_"
  
  hdEntry :: Ident
  hdEntry = name hdEntryStr
  
  hdEntryStr :: FastString
  hdEntryStr = fsLit "h$e"
  
  hdApGen :: JStgExpr
  hdApGen = global (identFS hdApGenStr)
  
  hdApGenStr :: Ident
  hdApGenStr = name "h$ap_gen"
  
  hdApGenFastStr :: Ident
  hdApGenFastStr = name $ fsLit $ unpackFS (identFS hdApGenStr) ++ "_fast"
  
  hdLog :: JStgExpr
  hdLog = global hdLogStr
  
  hdLogStr :: FastString
  hdLogStr = fsLit "h$log"
  
  hdMkFunctionPtr :: JStgExpr
  hdMkFunctionPtr = global "h$mkFunctionPtr"
  
  hdInitStatic :: JStgExpr
  hdInitStatic = global (identFS hdInitStaticStr)
  
  hdInitStaticStr :: Ident
  hdInitStaticStr = name "h$initStatic"
  
  hdHsSptInsert :: JStgExpr
  hdHsSptInsert = global "h$hs_spt_insert"
  
  hdCurrentThread :: JStgExpr
  hdCurrentThread = global (identFS hdCurrentThreadStr)
  
  hdCurrentThreadStr :: Ident
  hdCurrentThreadStr = name "h$currentThread"
  
  hdWakeupThread :: FastString
  hdWakeupThread = fsLit "h$wakeupThread"
  
  hdPaps :: JStgExpr
  hdPaps = global hdPapsStr
  
  hdPapsStr :: FastString
  hdPapsStr = fsLit "h$paps"
  
  hdPapStr_ :: FastString
  hdPapStr_ = fsLit "h$pap_"
  
  hdLazyEntryStr :: Ident
  hdLazyEntryStr = name "h$lazy_e"
  
  hdUnboxEntry :: JStgExpr
  hdUnboxEntry = global (identFS hdUnboxEntryStr)
  
  hdUnboxEntryStr :: Ident
  hdUnboxEntryStr = name "h$unbox_e"
  
  hdMaskFrame :: JStgExpr
  hdMaskFrame = global (identFS hdMaskFrameStr)
  
  hdMaskFrameStr :: Ident
  hdMaskFrameStr = name "h$maskFrame"
  
  hdUnMaskFrameStr :: Ident
  hdUnMaskFrameStr = name "h$unmaskFrame"
  
  hdReturnF :: JStgExpr
  hdReturnF = global (identFS hdReturnFStr)
  
  hdReturnFStr :: Ident
  hdReturnFStr = name "h$returnf"
  
  hdResumeEntryStr :: Ident
  hdResumeEntryStr = name "h$resume_e"
  
  hdFlushStdout :: JStgExpr
  hdFlushStdout = global (identFS hdFlushStdoutStr)
  
  hdFlushStdoutStr :: Ident
  hdFlushStdoutStr = name "h$flushStdout"
  
  hdFlushStdoutEntry :: JStgExpr
  hdFlushStdoutEntry = global (identFS hdFlushStdoutEntryStr)
  
  hdFlushStdoutEntryStr :: Ident
  hdFlushStdoutEntryStr = name "h$flushStdout_e"
  
  hdRunIOEntry :: JStgExpr
  hdRunIOEntry = global (identFS hdRunIOEntryStr)
  
  hdRunIOEntryStr :: Ident
  hdRunIOEntryStr = name "h$runio_e"
  
  hdReduce :: JStgExpr
  hdReduce = global (identFS hdReduceStr)
  
  hdReduceStr :: Ident
  hdReduceStr = name "h$reduce"
  
  hdThrowStr :: FastString
  hdThrowStr = fsLit "h$throw"
  
  hdRaiseAsyncFrame :: JStgExpr
  hdRaiseAsyncFrame = global (identFS hdRaiseAsyncFrameStr)
  
  hdRaiseAsyncFrameStr :: Ident
  hdRaiseAsyncFrameStr = name "h$raiseAsync_frame"
  
  hdRaiseAsyncEntry :: JStgExpr
  hdRaiseAsyncEntry = global (identFS hdRaiseAsyncEntryStr)
  
  hdRaiseAsyncEntryStr :: Ident
  hdRaiseAsyncEntryStr = name "h$raiseAsync_e"
  
  hdRaiseEntry :: JStgExpr
  hdRaiseEntry = global (identFS hdRaiseEntryStr)
  
  hdRaiseEntryStr :: Ident
  hdRaiseEntryStr = name "h$raise_e"
  
  hdKeepAliveEntry :: JStgExpr
  hdKeepAliveEntry = global (identFS hdKeepAliveEntryStr)
  
  hdKeepAliveEntryStr :: Ident
  hdKeepAliveEntryStr = name "h$keepAlive_e"
  
  hdSelect2Return :: JStgExpr
  hdSelect2Return = global (identFS hdSelect2ReturnStr)
  
  hdSelect2ReturnStr :: Ident
  hdSelect2ReturnStr = name "h$select2_ret"
  
  hdSelect2Entry :: JStgExpr
  hdSelect2Entry = global (identFS hdSelect2EntryStr)
  
  hdSelect2EntryStr :: Ident
  hdSelect2EntryStr = name "h$select2_e"
  
  hdSelect1Ret :: JStgExpr
  hdSelect1Ret = global (identFS hdSelect1RetStr)
  
  hdSelect1RetStr :: Ident
  hdSelect1RetStr = name "h$select1_ret"
  
  hdSelect1EntryStr :: Ident
  hdSelect1EntryStr = name "h$select1_e"
  
  hdStaticThunkStr :: FastString
  hdStaticThunkStr = fsLit "h$static_thunk"
  
  hdStaticThunksStr
    , hdStaticThunksArrStr
    , hdCAFsStr
    , hdCAFsResetStr :: Ident
  hdStaticThunksStr    = name "h$staticThunks"
  hdStaticThunksArrStr = name "h$staticThunksArr"
  hdCAFsStr            = name "h$CAFs"
  hdCAFsResetStr       = name "h$CAFsReset"
  
  hdUpdThunkEntryStr :: Ident
  hdUpdThunkEntryStr = name "h$upd_thunk_e"
  
  hdAp3EntryStr :: Ident
  hdAp3EntryStr = name "h$ap3_e"
  
  hdAp2EntryStr :: Ident
  hdAp2EntryStr = name "h$ap2_e"
  
  hdAp1EntryStr :: Ident
  hdAp1EntryStr = name "h$ap1_e"
  
  hdDataToTagEntryStr :: Ident
  hdDataToTagEntryStr = name "h$dataToTag_e"
  
  hdTagToEnum :: FastString
  hdTagToEnum = fsLit "h$tagToEnum"
  
  hdCatchEntryStr :: Ident
  hdCatchEntryStr = name "h$catch_e"
  
  hdNoopStr :: Ident
  hdNoopStr = name "h$noop"
  
  hdNoopEntry :: JStgExpr
  hdNoopEntry = global (identFS hdNoopEntryStr)
  
  hdNoopEntryStr :: Ident
  hdNoopEntryStr = name "h$noop_e"
  
  hdC0 :: JStgExpr
  hdC0 = global (identFS hdC0Str)
  
  hdC :: JStgExpr
  hdC = global (identFS hdCStr)
  
  hdC0Str :: Ident
  hdC0Str = name "h$c0"
  
  hdCStr :: Ident
  hdCStr = name "h$c"
  
  hdData2Entry :: Ident
  hdData2Entry = name "h$data2_e"
  
  hdData1Entry :: Ident
  hdData1Entry = name "h$data1_e"
  
  hdTrueEntry :: Ident
  hdTrueEntry = name "h$true_e"
  
  hdFalseEntry :: Ident
  hdFalseEntry = name "h$false_e"
  
  hdDoneMainEntry :: JStgExpr
  hdDoneMainEntry = global (identFS hdDoneMainEntryStr)
  
  hdDoneMainEntryStr :: Ident
  hdDoneMainEntryStr = name "h$doneMain_e"
  
  hdDoneMain :: JStgExpr
  hdDoneMain = global "h$doneMain"
  
  hdDone :: Ident
  hdDone = name "h$done"
  
  hdExitProcess :: FastString
  hdExitProcess = "h$exitProcess"
  
  hdTraceAlloc :: FastString
  hdTraceAlloc = fsLit "h$traceAlloc"
  
  hdDebugAllocNotifyAlloc :: FastString
  hdDebugAllocNotifyAlloc = fsLit "h$debugAlloc_notifyAlloc"
  
  hdRtsTraceForeign
    , hdRtsProfiling
    , hdCtFun
    , hdCtCon
    , hdCtThunk
    , hdCtPap
    , hdCtBlackhole
    , hdCtStackFrame
    , hdCtVtPtr
    , hdVtVoid
    , hdVtInt
    , hdVtDouble
    , hdVtLong
    , hdVtAddr
    , hdVtObj
    , hdVtArr :: Ident
  hdRtsTraceForeign = name "h$rts_traceForeign"
  hdRtsProfiling    = name "h$rts_profiling"
  hdCtFun           = name "h$ct_fun"
  hdCtCon           = name "h$ct_con"
  hdCtThunk         = name "h$ct_thunk"
  hdCtPap           = name "h$ct_pap"
  hdCtBlackhole     = name "h$ct_blackhole"
  hdCtStackFrame    = name "h$ct_stackframe"
  hdCtVtPtr         = name "h$vt_ptr"
  hdVtVoid          = name "h$vt_void"
  hdVtInt           = name "h$vt_int"
  hdVtDouble        = name "h$vt_double"
  hdVtLong          = name "h$vt_long"
  hdVtAddr          = name "h$vt_addr"
  hdVtObj           = name "h$vt_obj"
  hdVtArr           = name "h$vt_arr"
  
  
  hdLoads :: Array Int Ident
  hdLoads = listArray (1,32) [ name . mkFastStringByteString $ hdlB <> BSC.pack (show n)
                             | n <- [1..32::Int]
                             ]
  
  ----------------------------------------- Precompiled Aps ----------------------
  hdAp00 :: JStgExpr
  hdAp00 = global (identFS hdAp00Str)
  
  hdAp00Str :: Ident
  hdAp00Str = name "h$ap_0_0"
  
  hdAp00FastStr :: FastString
  hdAp00FastStr = fsLit "h$ap_0_0_fast"
  
  hdAp11Fast :: FastString
  hdAp11Fast = fsLit "h$ap_1_1_fast"
  
  hdAp10 :: JStgExpr
  hdAp10 = global "h$ap_1_0"
  
  hdAp33FastStr :: FastString
  hdAp33FastStr = fsLit "h$ap_3_3_fast"
  
  hdAp22FastStr :: FastString
  hdAp22FastStr = fsLit "h$ap_2_2_fast"
  
  ----------------------------------------- ByteArray -----------------------------
  hdNewByteArrayStr :: FastString
  hdNewByteArrayStr = "h$newByteArray"
  
  hdCopyMutableByteArrayStr :: FastString
  hdCopyMutableByteArrayStr = "h$copyMutableByteArray"
  
  hdCheckOverlapByteArrayStr :: FastString
  hdCheckOverlapByteArrayStr = "h$checkOverlapByteArray"
  
  hdShrinkMutableCharArrayStr :: FastString
  hdShrinkMutableCharArrayStr = "h$shrinkMutableCharArray"
  
  ----------------------------------------- EventLog -----------------------------
  hdTraceEventStr :: FastString
  hdTraceEventStr = "h$traceEvent"
  
  hdTraceEventBinaryStr :: FastString
  hdTraceEventBinaryStr = "h$traceEventBinary"
  
  hdTraceMarkerStr :: FastString
  hdTraceMarkerStr = "h$traceMarker"
  
  ----------------------------------------- FFI ----------------------------------
  hdThrowJSException :: JStgExpr
  hdThrowJSException = global $ fsLit "h$throwJSException"
  
  hdUnboxFFIResult :: JStgExpr
  hdUnboxFFIResult = global (identFS hdUnboxFFIResultStr)
  
  hdUnboxFFIResultStr :: Ident
  hdUnboxFFIResultStr = name "h$unboxFFIResult"
  
  hdMkForeignCallback :: JStgExpr
  hdMkForeignCallback = global $ fsLit "h$mkForeignCallback"
  
  hdTraceForeign :: JStgExpr
  hdTraceForeign = global $ fsLit "h$traceForeign"
  
  hdBuildObject :: JStgExpr
  hdBuildObject = global hdBuildObjectStr
  
  hdBuildObjectStr :: FastString
  hdBuildObjectStr = fsLit "h$buildObject"
  
  hdCallDynamicStr :: FastString
  hdCallDynamicStr = fsLit "h$callDynamic"
  
  except :: JStgExpr
  except = global $ identFS exceptStr
  
  exceptStr :: Ident
  exceptStr = name $ fsLit "except"
  
  excepStr :: FastString
  excepStr = fsLit "excep"
  
  ----------------------------------------- Accessors -----------------------------
  
  -- for almost all other symbols that are faststrings we turn 'foo' into 'fooStr'
  -- because these are overloaded with JStgExpr's. But for accessors we leave
  -- these as FastStrings because they will become Idents after the refactor.
  mv :: FastString
  mv = fsLit "mv"
  
  lngth :: FastString
  lngth = fsLit "length"
  
  -- | only for byte arrays. This is a JS byte array method
  len :: FastString
  len = fsLit "len"
  
  slice :: FastString
  slice = fsLit "slice"
  
  this :: JStgExpr
  this = global "this"
  
  arr :: FastString
  arr = fsLit "arr"
  
  dv :: FastString
  dv = fsLit "dv"
  
  d1, d2, d3 :: JStgExpr
  d1 = global d1Str
  d2 = global d2Str
  d3 = global d3Str
  
  d1Str, d2Str, d3Str :: FastString
  d1Str = fsLit "d1"
  d2Str = fsLit "d2"
  d3Str = fsLit "d3"
  
  getInt16 :: FastString
  getInt16 = "getInt16"
  
  getUint16 :: FastString
  getUint16 = "getUint16"
  
  getInt32 :: FastString
  getInt32 = "getInt32"
  
  getUint32 :: FastString
  getUint32 = "getUint32"
  
  getFloat32 :: FastString
  getFloat32 = "getFloat32"
  
  getFloat64 :: FastString
  getFloat64 = "getFloat64"
  
  setInt16 :: FastString
  setInt16 = "setInt16"
  
  setUint16 :: FastString
  setUint16 = "setUint16"
  
  setInt32 :: FastString
  setInt32 = "setInt32"
  
  setUint32 :: FastString
  setUint32 = "setUint32"
  
  setFloat32 :: FastString
  setFloat32 = "setFloat32"
  
  setFloat64 :: FastString
  setFloat64 = "setFloat64"
  
  i3, u8, u1, f6, f3 :: FastString
  i3 = "i3"
  u8 = "u8"
  u1 = "u1"
  f6 = "f6"
  f3 = "f3"
  
  val :: FastString
  val = fsLit "val"
  
  label :: FastString
  label = fsLit "label"
  
  mask :: FastString
  mask = fsLit "mask"
  
  unMask :: FastString
  unMask = fsLit "unmask"
  
  resume :: FastString
  resume = "resume"
  
  f :: FastString
  f = fsLit "f"
  
  n :: FastString
  n = fsLit "n"
  
  hasOwnProperty :: FastString
  hasOwnProperty = fsLit "hasOwnProperty"
  
  hdCollectProps :: FastString
  hdCollectProps = fsLit "h$collectProps"
  
  replace :: FastString
  replace = fsLit "replace"
  
  substring :: FastString
  substring = fsLit "substring"
  
  trace :: FastString
  trace = fsLit "trace"
  
  apply :: FastString
  apply = fsLit "apply"
  
  ----------------------------------------- STM ----------------------------------
  hdMVar :: JStgExpr
  hdMVar = global hdMVarStr
  
  hdMVarStr :: FastString
  hdMVarStr = fsLit "h$MVar"
  
  hdTakeMVar :: JStgExpr
  hdTakeMVar = global hdTakeMVarStr
  
  hdTakeMVarStr :: FastString
  hdTakeMVarStr = fsLit "h$takeMVar"
  
  hdTryTakeMVarStr :: FastString
  hdTryTakeMVarStr = fsLit "h$tryTakeMVar"
  
  hdPutMVarStr :: FastString
  hdPutMVarStr = fsLit "h$putMVar"
  
  hdTryPutMVarStr :: FastString
  hdTryPutMVarStr = fsLit "h$tryPutMVar"
  
  hdNewTVar :: FastString
  hdNewTVar = fsLit "h$newTVar"
  
  hdReadTVar :: FastString
  hdReadTVar = fsLit "h$readTVar"
  
  hdReadTVarIO :: FastString
  hdReadTVarIO = fsLit "h$readTVarIO"
  
  hdWriteTVar :: FastString
  hdWriteTVar = fsLit "h$writeTVar"
  
  hdReadMVarStr :: FastString
  hdReadMVarStr = fsLit "h$readMVar"
  
  hdStmRemoveBlockedThreadStr :: FastString
  hdStmRemoveBlockedThreadStr = fsLit "h$stmRemoveBlockedThread"
  
  hdStmStartTransactionStr :: FastString
  hdStmStartTransactionStr = fsLit "h$stmStartTransaction"
  
  hdAtomicallyEntry :: JStgExpr
  hdAtomicallyEntry = global (identFS hdAtomicallyEntryStr)
  
  hdAtomicallyEntryStr :: Ident
  hdAtomicallyEntryStr = name $ fsLit "h$atomically_e"
  
  hdAtomicallyStr :: FastString
  hdAtomicallyStr = "h$atomically"
  
  hdStgResumeRetryEntry :: JStgExpr
  hdStgResumeRetryEntry = global (identFS hdStgResumeRetryEntryStr)
  
  hdStgResumeRetryEntryStr :: Ident
  hdStgResumeRetryEntryStr = name $ fsLit "h$stmResumeRetry_e"
  
  hdStmCommitTransactionStr :: FastString
  hdStmCommitTransactionStr = fsLit "h$stmCommitTransaction"
  
  hdStmValidateTransactionStr :: FastString
  hdStmValidateTransactionStr = "h$stmValidateTransaction"
  
  hdStmCatchRetryEntry :: JStgExpr
  hdStmCatchRetryEntry = global (identFS hdStmCatchRetryEntryStr)
  
  hdStmCatchRetryEntryStr :: Ident
  hdStmCatchRetryEntryStr = name $ fsLit "h$stmCatchRetry_e"
  
  hdStmRetryStr :: FastString
  hdStmRetryStr = fsLit "h$stmRetry"
  
  hdStmCatchRetryStr :: FastString
  hdStmCatchRetryStr = fsLit "h$stmCatchRetry"
  
  hdStmCatchEntry :: JStgExpr
  hdStmCatchEntry = global (identFS hdStmCatchEntryStr)
  
  hdCatchStmStr :: FastString
  hdCatchStmStr = fsLit "h$catchStm"
  
  hdStmCatchEntryStr :: Ident
  hdStmCatchEntryStr = name $ fsLit "h$catchStm_e"
  
  hdRetryInterrupted :: JStgExpr
  hdRetryInterrupted = global (identFS hdRetryInterruptedStr)
  
  hdRetryInterruptedStr :: Ident
  hdRetryInterruptedStr = name $ fsLit "h$retryInterrupted"
  
  hdMaskUnintFrame :: JStgExpr
  hdMaskUnintFrame = global (identFS hdMaskUnintFrameStr)
  
  hdMaskUnintFrameStr :: Ident
  hdMaskUnintFrameStr = name $ fsLit "h$maskUnintFrame"
  
  hdReschedule :: JStgExpr
  hdReschedule = global (identFS hdRescheduleStr)
  
  hdRescheduleStr :: Ident
  hdRescheduleStr = name $ fsLit "h$reschedule"
  
  hdRestoreThread :: JStgExpr
  hdRestoreThread = global (identFS hdRestoreThreadStr)
  
  hdRestoreThreadStr :: Ident
  hdRestoreThreadStr = name $ fsLit "h$restoreThread"
  
  hdFinishedThread :: FastString
  hdFinishedThread = fsLit "h$finishThread"
  
  ----------------------------------------- Z-Encodings ---------------------------
  hdPrimOpStr :: FastString
  hdPrimOpStr = fsLit "h$primop_"
  
  wrapperColonStr :: FastString
  wrapperColonStr = fsLit "ghczuwrapperZC" -- equivalent non-z-encoding => ghc_wrapper:
  
  hdInternalExceptionTypeDivZero :: JStgExpr
  hdInternalExceptionTypeDivZero = global "h$ghczminternalZCGHCziInternalziExceptionziTypezidivZZeroException"
  
  hdInternalExceptionTypeOverflow :: JStgExpr
  hdInternalExceptionTypeOverflow = global "h$ghczminternalZCGHCziInternalziExceptionziTypezioverflowException"
  
  hdInternalExceptionTypeUnderflow :: JStgExpr
  hdInternalExceptionTypeUnderflow = global "h$ghczminternalZCGHCziInternalziExceptionziTypeziunderflowException"
  
  hdInternalExceptionControlExceptionBaseNonTermination :: JStgExpr
  hdInternalExceptionControlExceptionBaseNonTermination = global "h$ghczminternalZCGHCziInternalziControlziExceptionziBasezinonTermination"
  
  hdGhcInternalIOHandleFlush :: JStgExpr
  hdGhcInternalIOHandleFlush = global "h$ghczminternalZCGHCziInternalziIOziHandlezihFlush"
  
  hdGhcInternalIOHandleFDStdout :: JStgExpr
  hdGhcInternalIOHandleFDStdout = global "h$ghczminternalZCGHCziInternalziIOziHandleziFDzistdout"
  
  hdGhcInternalJSPrimValConEntryStr :: FastString
  hdGhcInternalJSPrimValConEntryStr = fsLit "h$ghczminternalZCGHCziInternalziJSziPrimziJSVal_con_e"
  
  ----------------------------------------- Profiling -----------------------------
  hdBuildCCSPtrStr :: FastString
  hdBuildCCSPtrStr = "h$buildCCSPtr"
  
  hdClearCCSStr :: FastString
  hdClearCCSStr = "h$clearCCS"
  
  hdRestoreCCSStr :: FastString
  hdRestoreCCSStr = fsLit "h$restoreCCS"
  
  hdSetCcsEntry :: JStgExpr
  hdSetCcsEntry = global (identFS hdSetCcsEntryStr)
  
  hdSetCcsEntryStr :: Ident
  hdSetCcsEntryStr = name $ fsLit "h$setCcs_e"
  
  ccStr :: FastString
  ccStr = fsLit "cc"
  ----------------------------------------- Others -------------------------------
  unknown :: FastString
  unknown = fsLit "<unknown>"
  
  typeof :: FastString
  typeof = fsLit "typeof"
  
  throwStr :: FastString
  throwStr = fsLit "throw"
  
  hdCheckObj :: JStgExpr
  hdCheckObj = global $ fsLit "h$checkObj"
  
  console :: JStgExpr
  console = global consoleStr
  
  consoleStr :: FastString
  consoleStr = fsLit "console"
  
  arguments :: JStgExpr
  arguments = global argumentsStr
  
  argumentsStr :: FastString
  argumentsStr = fsLit "arguments"
  
  hdReportHeapOverflow :: JStgExpr
  hdReportHeapOverflow = global (identFS hdReportHeapOverflowStr)
  
  hdReportHeapOverflowStr :: Ident
  hdReportHeapOverflowStr = name $ fsLit "h$reportHeapOverflow"
  
  hdReportStackOverflow :: JStgExpr
  hdReportStackOverflow = global (identFS hdReportStackOverflowStr)
  
  hdReportStackOverflowStr :: Ident
  hdReportStackOverflowStr = name $ fsLit "h$reportStackOverflow"
  
  hdDumpRes :: JStgExpr
  hdDumpRes = global (identFS hdDumpResStr)
  
  hdDumpResStr :: Ident
  hdDumpResStr = name $ fsLit "h$dumpRes"
  
  ghcjsArray :: FastString
  ghcjsArray = fsLit "__ghcjsArray"
  
  ----------------------------------------- Compact -------------------------------
  
  hdCompactSize :: FastString
  hdCompactSize = fsLit "h$compactSize"
  
  hdCompactAddWithSharing :: FastString
  hdCompactAddWithSharing = fsLit "h$compactAddWithSharing"
  
  hdCompactAdd :: FastString
  hdCompactAdd = fsLit "h$compactAdd"
  
  hdCompactFixupPointers :: FastString
  hdCompactFixupPointers = fsLit "h$compactFixupPointers"
  
  hdCompactAllocateBlock :: FastString
  hdCompactAllocateBlock = fsLit "h$compactAllocateBlock"
  
  hdCompactGetNextBlock :: FastString
  hdCompactGetNextBlock = fsLit "h$compactGetNextBlock"
  
  hdCompactGetFirstBlock :: FastString
  hdCompactGetFirstBlock = fsLit "h$compactGetFirstBlock"
  
  hdCompactContainsAny :: FastString
  hdCompactContainsAny = fsLit "h$compactContainsAny"
  
  hdCompactContains :: FastString
  hdCompactContains = fsLit "h$compactContains"
  
  hdCompactResize :: FastString
  hdCompactResize = fsLit "h$compactResize"
  
  hdCompactNew :: FastString
  hdCompactNew = fsLit "h$compactNew"
  
  ----------------------------------------- Stable Pointers -----------------------
  
  hdStableNameInt :: FastString
  hdStableNameInt = fsLit "h$stableNameInt"
  
  hdMakeStableName :: FastString
  hdMakeStableName = fsLit "h$makeStableName"
  
  hdDeRefStablePtr :: FastString
  hdDeRefStablePtr = fsLit "h$deRefStablePtr"
  
  hdStablePtrBuf :: JStgExpr
  hdStablePtrBuf = global "h$stablePtrBuf"
  
  hdMakeStablePtrStr :: FastString
  hdMakeStablePtrStr = fsLit "h$makeStablePtr"
  
  ------------------------------- Weak Pointers -----------------------------------
  
  hdKeepAlive :: FastString
  hdKeepAlive = fsLit "h$keepAlive"
  
  hdFinalizeWeak :: FastString
  hdFinalizeWeak = fsLit "h$finalizeWeak"
  
  hdMakeWeakNoFinalizer :: FastString
  hdMakeWeakNoFinalizer = fsLit "h$makeWeakNoFinalizer"
  
  hdMakeWeak :: FastString
  hdMakeWeak = fsLit "h$makeWeak"
  
  ------------------------------- Concurrency Primitives -------------------------
  
  hdGetThreadLabel :: FastString
  hdGetThreadLabel = fsLit "h$getThreadLabel"
  
  hdListThreads :: FastString
  hdListThreads = fsLit "h$listThreads"
  
  hdThreadStatus :: FastString
  hdThreadStatus = fsLit "h$threadStatus"
  
  hdYield :: FastString
  hdYield = fsLit "h$yield"
  
  hdKillThread :: FastString
  hdKillThread = fsLit "h$killThread"
  
  hdFork :: FastString
  hdFork = fsLit "h$fork"
  
  ------------------------------- Delay/Wait Ops ---------------------------------
  
  hdWaitWrite :: FastString
  hdWaitWrite = fsLit "h$waitWrite"
  
  hdWaitRead :: FastString
  hdWaitRead = fsLit "h$waitRead"
  
  hdDelayThread :: FastString
  hdDelayThread = fsLit "h$delayThread"
  
  ------------------------------- Exceptions --------------------------------------
  
  hdCatchStr :: FastString
  hdCatchStr = fsLit "h$catch"
  
  hdMaskAsyncStr :: FastString
  hdMaskAsyncStr = fsLit "h$maskAsync"
  
  hdMaskUnintAsyncStr :: FastString
  hdMaskUnintAsyncStr = fsLit "h$maskUnintAsync"
  
  hdUnmaskAsyncStr :: FastString
  hdUnmaskAsyncStr = fsLit "h$unmaskAsync"
  
  ------------------------------- Mutable variables --------------------------------------
  
  hdMutVarStr :: FastString
  hdMutVarStr = fsLit "h$MutVar"
  
  hdAtomicModifyMutVar2Str :: FastString
  hdAtomicModifyMutVar2Str = fsLit "h$atomicModifyMutVar2"
  
  hdAtomicModifyMutVarStr :: FastString
  hdAtomicModifyMutVarStr = fsLit "h$atomicModifyMutVar"
  
  ------------------------------- Addr# ------------------------------------------
  
  hdComparePointerStr :: FastString
  hdComparePointerStr = fsLit "h$comparePointer"
  
  ------------------------------- Byte Arrays -------------------------------------
  
  hdCompareByteArraysStr :: FastString
  hdCompareByteArraysStr = fsLit "h$compareByteArrays"
  
  hdResizeMutableByteArrayStr :: FastString
  hdResizeMutableByteArrayStr = fsLit "h$resizeMutableByteArray"
  
  hdShrinkMutableByteArrayStr :: FastString
  hdShrinkMutableByteArrayStr = fsLit "h$shrinkMutableByteArray"
  
  ------------------------------- Arrays ------------------------------------------
  
  hdCopyMutableArrayStr :: FastString
  hdCopyMutableArrayStr = fsLit "h$copyMutableArray"
  
  hdNewArrayStr :: FastString
  hdNewArrayStr = fsLit "h$newArray"
  
  hdSliceArrayStr :: FastString
  hdSliceArrayStr = fsLit "h$sliceArray"
  
  ------------------------------ Float --------------------------------------------
  
  hdDecodeFloatIntStr :: FastString
  hdDecodeFloatIntStr = fsLit "h$decodeFloatInt"
  
  hdCastFloatToWord32Str :: FastString
  hdCastFloatToWord32Str = fsLit "h$castFloatToWord32"
  
  hdCastWord32ToFloatStr :: FastString
  hdCastWord32ToFloatStr = fsLit "h$castWord32ToFloat"
  
  ------------------------------ Double -------------------------------------------
  
  hdDecodeDouble2IntStr :: FastString
  hdDecodeDouble2IntStr = fsLit "h$decodeDouble2Int"
  
  hdDecodeDoubleInt64Str :: FastString
  hdDecodeDoubleInt64Str = fsLit "h$decodeDoubleInt64"
  
  hdCastDoubleToWord64Str :: FastString
  hdCastDoubleToWord64Str = fsLit "h$castDoubleToWord64"
  
  hdCastWord64ToDoubleStr :: FastString
  hdCastWord64ToDoubleStr = fsLit "h$castWord64ToDouble"
  
  ------------------------------ Word -------------------------------------------
  
  hdReverseWordStr :: FastString
  hdReverseWordStr = fsLit "h$reverseWord"
  
  hdClz8Str
    , hdClz16Str
    , hdClz32Str
    , hdClz64Str
    , hdCtz8Str
    , hdCtz16Str
    , hdCtz32Str
    , hdCtz64Str :: FastString
  
  hdClz8Str  = fsLit "h$clz8"
  hdClz16Str = fsLit "h$clz16"
  hdClz32Str = fsLit "h$clz32"
  hdClz64Str = fsLit "h$clz64"
  hdCtz8Str  = fsLit "h$ctz8"
  hdCtz16Str = fsLit "h$ctz16"
  hdCtz32Str = fsLit "h$ctz32"
  hdCtz64Str = fsLit "h$ctz64"
  
  hdBSwap64Str :: FastString
  hdBSwap64Str = "h$bswap64"
  
  hdPExit8Str
    , hdPExit16Str
    , hdPExit32Str
    , hdPExit64Str
    , hdPDep8Str
    , hdPDep16Str
    , hdPDep32Str
    , hdPDep64Str :: FastString
  
  hdPExit8Str  = fsLit "h$pext8"
  hdPExit16Str = fsLit "h$pext16"
  hdPExit32Str = fsLit "h$pext32"
  hdPExit64Str = fsLit "h$pext64"
  hdPDep8Str   = fsLit "h$pdep8"
  hdPDep16Str  = fsLit "h$pdep16"
  hdPDep32Str  = fsLit "h$pdep32"
  hdPDep64Str  = fsLit "h$pdep64"
  
  hdPopCntTab :: JStgExpr
  hdPopCntTab = global "h$popCntTab"
  
  hdPopCnt32Str :: FastString
  hdPopCnt32Str = fsLit "h$popCnt32"
  
  hdPopCnt64Str :: FastString
  hdPopCnt64Str = fsLit "h$popCnt64"
  
  hdQuotRem2Word32Str :: FastString
  hdQuotRem2Word32Str = fsLit "h$quotRem2Word32"
  
  hdQuotRemWord32Str :: FastString
  hdQuotRemWord32Str = fsLit "h$quotRemWord32"
  
  hdRemWord32Str :: FastString
  hdRemWord32Str = fsLit "h$remWord32"
  
  hdQuotWord32Str :: FastString
  hdQuotWord32Str = fsLit "h$quotWord32"
  
  hdMul2Word32Str :: FastString
  hdMul2Word32Str = fsLit "h$mul2Word32"
  
  hdMulImulStr :: FastString
  hdMulImulStr = fsLit "Math.imul"
  
  hdWordAdd2 :: FastString
  hdWordAdd2 = fsLit "h$wordAdd2"
  
  hdHsPlusWord64Str :: FastString
  hdHsPlusWord64Str = fsLit "h$hs_plusWord64"
  
  hdHsMinusWord64Str :: FastString
  hdHsMinusWord64Str = fsLit "h$hs_minusWord64"
  
  hdHsTimesWord64Str :: FastString
  hdHsTimesWord64Str = fsLit "h$hs_timesWord64"
  
  hdHsQuotWord64Str :: FastString
  hdHsQuotWord64Str = fsLit "h$hs_quotWord64"
  
  hdHsRemWord64Str :: FastString
  hdHsRemWord64Str = fsLit "h$hs_remWord64"
  
  hdHsUncheckedShiftRWord64Str :: FastString
  hdHsUncheckedShiftRWord64Str = fsLit "h$hs_uncheckedShiftRWord64"
  
  hdHsUncheckedShiftLWord64Str :: FastString
  hdHsUncheckedShiftLWord64Str = fsLit "h$hs_uncheckedShiftLWord64"
  
  hdHsPlusInt64Str :: FastString
  hdHsPlusInt64Str = fsLit "h$hs_plusInt64"
  
  hdHsMinusInt64Str :: FastString
  hdHsMinusInt64Str = fsLit "h$hs_minusInt64"
  
  hdHsTimesInt64Str :: FastString
  hdHsTimesInt64Str = fsLit "h$hs_timesInt64"
  
  hdHsQuotInt64Str :: FastString
  hdHsQuotInt64Str = fsLit "h$hs_quotInt64"
  
  hdHsRemInt64Str :: FastString
  hdHsRemInt64Str = fsLit "h$hs_remInt64"
  
  hdHsUncheckedShiftLLInt64Str :: FastString
  hdHsUncheckedShiftLLInt64Str = fsLit "h$hs_uncheckedShiftLLInt64"
  
  hdHsUncheckedShiftRAInt64Str :: FastString
  hdHsUncheckedShiftRAInt64Str = fsLit "h$hs_uncheckedShiftRAInt64"
  
  hdHsUncheckedShiftRLInt64Str :: FastString
  hdHsUncheckedShiftRLInt64Str = fsLit "h$hs_uncheckedShiftRLInt64"
  
  hdHsTimesInt2Str :: FastString
  hdHsTimesInt2Str = fsLit "h$hs_timesInt2"
  
  ------------------------------ Linker -------------------------------------------
  
  hdEncodeModifiedUtf8Str :: FastString
  hdEncodeModifiedUtf8Str = fsLit "h$encodeModifiedUtf8"
  
  hdRawStringDataStr :: FastString
  hdRawStringDataStr = fsLit "h$rawStringData"
  
  hdPStr :: FastString
  hdPStr = fsLit "h$p"
  
  hdDStr :: FastString
  hdDStr = fsLit "h$d"
  
  hdDiStr :: FastString
  hdDiStr = fsLit "h$di"
  
  hdStcStr :: FastString
  hdStcStr = fsLit "h$stc"
  
  hdStlStr :: FastString
  hdStlStr = fsLit "h$stl"
  
  hdStiStr :: FastString
  hdStiStr = fsLit "h$sti"
  
  ------------------------------ Pack/Unpack --------------------------------------------
  
  hdDecodeUtf8Z :: FastString
  hdDecodeUtf8Z = fsLit "h$decodeUtf8z"
  