Safe Haskell	None
Language	GHC2024

GHC.Linker.Types

Contents

Bytecode Loader State
Linkable

Synopsis

newtype Loader = Loader {
- loader_state :: MVar (Maybe LoaderState)
}
data LoaderState = LoaderState {
- bco_loader_state :: !BytecodeLoaderState
- bcos_loaded :: !LinkableSet
- objs_loaded :: !LinkableSet
- pkgs_loaded :: !PkgsLoaded
- temp_sos :: ![(FilePath, String)]
}
uninitializedLoader :: IO Loader
data BytecodeLoaderState = BytecodeLoaderState {
- homePackage_loaded :: BytecodeState
- externalPackage_loaded :: BytecodeState
}
data BytecodeState = BytecodeState {
- bco_linker_env :: !LinkerEnv
- bco_linked_breaks :: !LinkedBreaks
}
emptyBytecodeLoaderState :: BytecodeLoaderState
emptyBytecodeState :: BytecodeState
modifyHomePackageBytecodeState :: BytecodeLoaderState -> (BytecodeState -> BytecodeState) -> BytecodeLoaderState
modifyExternalPackageBytecodeState :: BytecodeLoaderState -> (BytecodeState -> BytecodeState) -> BytecodeLoaderState
modifyBytecodeLoaderState :: BytecodeLoaderStateModifier -> LoaderState -> (BytecodeState -> BytecodeState) -> LoaderState
lookupNameBytecodeState :: BytecodeLoaderState -> Name -> Maybe (Name, ForeignHValue)
lookupBreakArrayBytecodeState :: BytecodeLoaderState -> Module -> Maybe (ForeignRef BreakArray)
lookupInfoTableBytecodeState :: BytecodeLoaderState -> Name -> Maybe (Name, ItblPtr)
lookupAddressBytecodeState :: BytecodeLoaderState -> Name -> Maybe (Name, AddrPtr)
lookupCCSBytecodeState :: BytecodeLoaderState -> Module -> Maybe (Array BreakTickIndex (RemotePtr CostCentre))
type BytecodeLoaderStateModifier = BytecodeLoaderState -> (BytecodeState -> BytecodeState) -> BytecodeLoaderState
type BytecodeLoaderStateTraverser (m :: Type -> Type) = BytecodeLoaderState -> (BytecodeState -> m BytecodeState) -> m BytecodeLoaderState
traverseHomePackageBytecodeState :: Monad m => BytecodeLoaderState -> (BytecodeState -> m BytecodeState) -> m BytecodeLoaderState
traverseExternalPackageBytecodeState :: Monad m => BytecodeLoaderState -> (BytecodeState -> m BytecodeState) -> m BytecodeLoaderState
modifyClosureEnv :: BytecodeState -> (ClosureEnv -> ClosureEnv) -> BytecodeState
data LinkerEnv = LinkerEnv {
- closure_env :: !ClosureEnv
- itbl_env :: !ItblEnv
- addr_env :: !AddrEnv
}
emptyLinkerEnv :: LinkerEnv
type ClosureEnv = NameEnv (Name, ForeignHValue)
emptyClosureEnv :: ClosureEnv
extendClosureEnv :: ClosureEnv -> [(Name, ForeignHValue)] -> ClosureEnv
data LinkedBreaks = LinkedBreaks {
- breakarray_env :: !(ModuleEnv (ForeignRef BreakArray))
- ccs_env :: !(ModuleEnv (Array BreakTickIndex (RemotePtr CostCentre)))
}
emptyLinkedBreaks :: LinkedBreaks
type LinkableSet = ModuleEnv Linkable
mkLinkableSet :: [Linkable] -> LinkableSet
unionLinkableSet :: LinkableSet -> LinkableSet -> LinkableSet
type ObjFile = FilePath
data SptEntry = SptEntry !Name !Fingerprint
data LibrarySpec
- = Objects [FilePath]
- | Archive FilePath
- | DLL String
- | DLLPath FilePath
- | Framework String
- | BytecodeLibrary FilePath
data LoadedPkgInfo = LoadedPkgInfo {
- loaded_pkg_uid :: !UnitId
- loaded_pkg_hs_objs :: ![LibrarySpec]
- loaded_pkg_non_hs_objs :: ![LibrarySpec]
- loaded_pkg_hs_dlls :: ![RemotePtr LoadedDLL]
- loaded_pkg_trans_deps :: UniqDSet UnitId
}
type PkgsLoaded = UniqDFM UnitId LoadedPkgInfo
type Linkable = LinkableWith (NonEmpty LinkablePart)
type WholeCoreBindingsLinkable = LinkableWith WholeCoreBindings
data LinkableWith parts = Linkable {
- linkableTime :: !UTCTime
- linkableModule :: !Module
- linkableParts :: parts
}
mkModuleByteCodeLinkable :: UTCTime -> ModuleByteCode -> Linkable
data LinkablePart
- = DotO ObjFile LinkableObjectSort
- | DotA FilePath
- | DotDLL FilePath
- | DotGBC ModuleByteCode
data LinkableObjectSort
- = ModuleObject
- | ForeignObject
linkableIsNativeCodeOnly :: Linkable -> Bool
linkableObjs :: Linkable -> [FilePath]
linkableLibs :: Linkable -> [LinkablePart]
linkableFiles :: Linkable -> [FilePath]
linkableBCOs :: Linkable -> [CompiledByteCode]
linkablePartBCOs :: LinkablePart -> [CompiledByteCode]
linkableModuleByteCodes :: Linkable -> [ModuleByteCode]
linkableNativeParts :: Linkable -> [LinkablePart]
linkablePartitionParts :: Linkable -> ([LinkablePart], [LinkablePart])
linkablePartPath :: LinkablePart -> Maybe FilePath
isNativeCode :: LinkablePart -> Bool
isNativeLib :: LinkablePart -> Bool
linkableFilterByteCode :: Linkable -> Maybe Linkable
linkableFilterNative :: Linkable -> Maybe Linkable
partitionLinkables :: [Linkable] -> ([Linkable], [Linkable])
data ModuleByteCode = ModuleByteCode {
- gbc_module :: Module
- gbc_compiled_byte_code :: CompiledByteCode
- gbc_foreign_files :: [FilePath]
}

Documentation

newtype Loader Source #

Constructors

Loader
Fields loader_state :: MVar (Maybe LoaderState)

data LoaderState Source #

Constructors

LoaderState

Fields

bco_loader_state :: !BytecodeLoaderState
Information about bytecode objects we have loaded into the interpreter.
bcos_loaded :: !LinkableSet
The currently loaded interpreted modules (home package)
objs_loaded :: !LinkableSet
And the currently-loaded compiled modules (home package)
pkgs_loaded :: !PkgsLoaded
The currently-loaded packages; haskell libraries, system libraries, transitive dependencies
temp_sos :: ![(FilePath, String)]
We need to remember the name of previous temporary DLL/.so libraries so we can link them (see #10322)

uninitializedLoader :: IO Loader Source #

Bytecode Loader State

data BytecodeLoaderState Source #

The BytecodeLoaderState captures all the information about bytecode loaded into the interpreter. It is separated into two parts. One for bytecode objects loaded by the home package and one for bytecode objects loaded from bytecode libraries for external packages. Much like the HPT/EPS split, the home package state can be unloaded by calling unload.

Constructors

BytecodeLoaderState
Fields homePackage_loaded :: BytecodeState Information about bytecode objects from the home package we have loaded into the interpreter. externalPackage_loaded :: BytecodeState Information about bytecode objects from external packages we have loaded into the interpreter.

data BytecodeState Source #

Constructors

BytecodeState
Fields bco_linker_env :: !LinkerEnv Current global mapping from Names to their true values bco_linked_breaks :: !LinkedBreaks Mapping from loaded modules to their breakpoint arrays

emptyBytecodeLoaderState :: BytecodeLoaderState Source #

emptyBytecodeState :: BytecodeState Source #

modifyHomePackageBytecodeState :: BytecodeLoaderState -> (BytecodeState -> BytecodeState) -> BytecodeLoaderState Source #

Only update the home package bytecode state.

modifyExternalPackageBytecodeState :: BytecodeLoaderState -> (BytecodeState -> BytecodeState) -> BytecodeLoaderState Source #

Only update the external package bytecode state.

modifyBytecodeLoaderState :: BytecodeLoaderStateModifier -> LoaderState -> (BytecodeState -> BytecodeState) -> LoaderState Source #

lookupNameBytecodeState :: BytecodeLoaderState -> Name -> Maybe (Name, ForeignHValue) Source #

Find a name loaded from bytecode

lookupBreakArrayBytecodeState :: BytecodeLoaderState -> Module -> Maybe (ForeignRef BreakArray) Source #

Look up a break array in the bytecode loader state.

lookupInfoTableBytecodeState :: BytecodeLoaderState -> Name -> Maybe (Name, ItblPtr) Source #

Look up an info table in the bytecode loader state.

lookupAddressBytecodeState :: BytecodeLoaderState -> Name -> Maybe (Name, AddrPtr) Source #

Look up an address in the bytecode loader state.

lookupCCSBytecodeState :: BytecodeLoaderState -> Module -> Maybe (Array BreakTickIndex (RemotePtr CostCentre)) Source #

Look up a cost centre stack in the bytecode loader state.

type BytecodeLoaderStateModifier = BytecodeLoaderState -> (BytecodeState -> BytecodeState) -> BytecodeLoaderState Source #

type BytecodeLoaderStateTraverser (m :: Type -> Type) = BytecodeLoaderState -> (BytecodeState -> m BytecodeState) -> m BytecodeLoaderState Source #

traverseHomePackageBytecodeState :: Monad m => BytecodeLoaderState -> (BytecodeState -> m BytecodeState) -> m BytecodeLoaderState Source #

Effectfully update the home package bytecode state.

traverseExternalPackageBytecodeState :: Monad m => BytecodeLoaderState -> (BytecodeState -> m BytecodeState) -> m BytecodeLoaderState Source #

Effectfully update the external package bytecode state.

modifyClosureEnv :: BytecodeState -> (ClosureEnv -> ClosureEnv) -> BytecodeState Source #

data LinkerEnv Source #

Information about loaded bytecode

Constructors

LinkerEnv

Fields

closure_env :: !ClosureEnv
Current global mapping from closure Names to their true values
itbl_env :: !ItblEnv
The current global mapping from RdrNames of DataCons to info table addresses. When a new LinkablePart is linked into the running image, or an existing module in the image is replaced, the itbl_env must be updated appropriately.
addr_env :: !AddrEnv
Like closure_env and itbl_env, but for top-level 'Addr#' literals, see Note [Generating code for top-level string literal bindings] in GHC.StgToByteCode.

emptyLinkerEnv :: LinkerEnv Source #

type ClosureEnv = NameEnv (Name, ForeignHValue) Source #

emptyClosureEnv :: ClosureEnv Source #

extendClosureEnv :: ClosureEnv -> [(Name, ForeignHValue)] -> ClosureEnv Source #

data LinkedBreaks Source #

BreakArrays and CCSs are allocated per-module at link-time.

Specifically, a module's BreakArray is allocated either: - When a BCO for that module is linked - When :break is used on a given module *before* the BCO has been linked.

We keep this structure in the LoaderState

Constructors

LinkedBreaks
Fields breakarray_env :: !(ModuleEnv (ForeignRef BreakArray)) Each `Module`s remote pointer of `BreakArray`. ccs_env :: !(ModuleEnv (Array BreakTickIndex (RemotePtr CostCentre))) Each `Module`s array of remote pointers of `CostCentre`. Untouched when not profiling.

emptyLinkedBreaks :: LinkedBreaks Source #

type LinkableSet = ModuleEnv Linkable Source #

mkLinkableSet :: [Linkable] -> LinkableSet Source #

unionLinkableSet :: LinkableSet -> LinkableSet -> LinkableSet Source #

Union of LinkableSets.

In case of conflict, keep the most recent Linkable (as per linkableTime)

type ObjFile = FilePath Source #

data SptEntry Source #

An entry to be inserted into a module's static pointer table. See Note [Grand plan for static forms] in GHC.Iface.Tidy.StaticPtrTable.

Constructors

SptEntry !Name !Fingerprint

Instances

Instances details

Binary SptEntry Source #
Instance details Defined in GHC.Types.SptEntry Methods put_ :: WriteBinHandle -> SptEntry -> IO () Source # put :: WriteBinHandle -> SptEntry -> IO (Bin SptEntry) Source # get :: ReadBinHandle -> IO SptEntry Source #
Outputable SptEntry Source #
Instance details Defined in GHC.Types.SptEntry Methods ppr :: SptEntry -> SDoc Source #

data LibrarySpec Source #

Constructors

Objects [FilePath]
Archive FilePath
DLL String
DLLPath FilePath
Framework String
BytecodeLibrary FilePath	A bytecode library file (.bytecodelib)

Instances

Instances details

Outputable LibrarySpec Source #
Instance details Defined in GHC.Linker.Types Methods ppr :: LibrarySpec -> SDoc Source #

data LoadedPkgInfo Source #

Constructors

LoadedPkgInfo
Fields loaded_pkg_uid :: !UnitId loaded_pkg_hs_objs :: ![LibrarySpec] loaded_pkg_non_hs_objs :: ![LibrarySpec] loaded_pkg_hs_dlls :: ![RemotePtr LoadedDLL] See Note [Looking up symbols in the relevant objects] loaded_pkg_trans_deps :: UniqDSet UnitId

Instances

Instances details

Outputable LoadedPkgInfo Source #
Instance details Defined in GHC.Linker.Types Methods ppr :: LoadedPkgInfo -> SDoc Source #

type PkgsLoaded = UniqDFM UnitId LoadedPkgInfo Source #

Linkable

type Linkable = LinkableWith (NonEmpty LinkablePart) Source #

type WholeCoreBindingsLinkable = LinkableWith WholeCoreBindings Source #

data LinkableWith parts Source #

Information we can use to dynamically link modules into the compiler

Constructors

Linkable
Fields linkableTime :: !UTCTime Time at which this linkable was built (i.e. when the bytecodes were produced, or the mod date on the files) linkableModule :: !Module The linkable module itself linkableParts :: parts Files and chunks of code to link.

Instances

Instances details

Functor LinkableWith Source #
Instance details Defined in GHC.Linker.Types Methods fmap :: (a -> b) -> LinkableWith a -> LinkableWith b Source # (<$) :: a -> LinkableWith b -> LinkableWith a Source #
Foldable LinkableWith Source #
Instance details Defined in GHC.Linker.Types Methods fold :: Monoid m => LinkableWith m -> m Source # foldMap :: Monoid m => (a -> m) -> LinkableWith a -> m Source # foldMap' :: Monoid m => (a -> m) -> LinkableWith a -> m Source # foldr :: (a -> b -> b) -> b -> LinkableWith a -> b Source # foldr' :: (a -> b -> b) -> b -> LinkableWith a -> b Source # foldl :: (b -> a -> b) -> b -> LinkableWith a -> b Source # foldl' :: (b -> a -> b) -> b -> LinkableWith a -> b Source # foldr1 :: (a -> a -> a) -> LinkableWith a -> a Source # foldl1 :: (a -> a -> a) -> LinkableWith a -> a Source # toList :: LinkableWith a -> [a] Source # null :: LinkableWith a -> Bool Source # length :: LinkableWith a -> Int Source # elem :: Eq a => a -> LinkableWith a -> Bool Source # maximum :: Ord a => LinkableWith a -> a Source # minimum :: Ord a => LinkableWith a -> a Source # sum :: Num a => LinkableWith a -> a Source # product :: Num a => LinkableWith a -> a Source #
Traversable LinkableWith Source #
Instance details Defined in GHC.Linker.Types Methods traverse :: Applicative f => (a -> f b) -> LinkableWith a -> f (LinkableWith b) Source # sequenceA :: Applicative f => LinkableWith (f a) -> f (LinkableWith a) Source # mapM :: Monad m => (a -> m b) -> LinkableWith a -> m (LinkableWith b) Source # sequence :: Monad m => LinkableWith (m a) -> m (LinkableWith a) Source #
Outputable a => Outputable (LinkableWith a) Source #
Instance details Defined in GHC.Linker.Types Methods ppr :: LinkableWith a -> SDoc Source #

mkModuleByteCodeLinkable :: UTCTime -> ModuleByteCode -> Linkable Source #

data LinkablePart Source #

Objects which have yet to be linked by the compiler

Constructors

DotO
Fields ObjFile An object file (.o) LinkableObjectSort Whether the object is an internal, intermediate build product that should not be adapted to the interpreter's way. Used for foreign stubs loaded from interfaces.
DotA FilePath	Static archive file (.a)
DotDLL FilePath	Dynamically linked library file (.so, .dll, .dylib)
DotGBC ModuleByteCode	A byte-code object, lives only in memory.

Instances

Instances details

Outputable LinkablePart Source #
Instance details Defined in GHC.Linker.Types Methods ppr :: LinkablePart -> SDoc Source #

data LinkableObjectSort Source #

Classify the provenance of .o products.

Constructors

ModuleObject	The object is the final product for a module. When linking splices, its file extension will be adapted to the interpreter's way if needed.
ForeignObject	The object was created from generated code for foreign stubs or foreign sources added by the user. Its file extension must be preserved, since there are no objects for alternative ways available.

linkableIsNativeCodeOnly :: Linkable -> Bool Source #

Return true if the linkable only consists of native code (no BCO)

linkableObjs :: Linkable -> [FilePath] Source #

List the native objects (.o) of a linkable

linkableLibs :: Linkable -> [LinkablePart] Source #

List the native libraries (.so/.dll) of a linkable

linkableFiles :: Linkable -> [FilePath] Source #

List the paths of the native objects and libraries (.o.so.dll)

linkableBCOs :: Linkable -> [CompiledByteCode] Source #

List the BCOs parts of a linkable.

This excludes the CoreBindings parts

linkablePartBCOs :: LinkablePart -> [CompiledByteCode] Source #

Retrieve the compiled byte-code from the linkable part.

Contrary to linkableBCOs, this includes byte-code from LazyBCOs.

linkableModuleByteCodes :: Linkable -> [ModuleByteCode] Source #

linkableNativeParts :: Linkable -> [LinkablePart] Source #

List the native linkable parts (.o.so.dll) of a linkable

linkablePartitionParts :: Linkable -> ([LinkablePart], [LinkablePart]) Source #

Split linkable parts into (native code parts, BCOs parts)

linkablePartPath :: LinkablePart -> Maybe FilePath Source #

Get the FilePath of linkable part (if applicable)

isNativeCode :: LinkablePart -> Bool Source #

Is the part a native object or library? (.o.so.dll)

isNativeLib :: LinkablePart -> Bool Source #

Is the part a native library? (.so/.dll)

linkableFilterByteCode :: Linkable -> Maybe Linkable Source #

Transform the LinkablePart list in this Linkable to contain only byte code If no LinkablePart remains, return Nothing.

linkableFilterNative :: Linkable -> Maybe Linkable Source #

Transform the LinkablePart list in this Linkable to contain only object code files (.o, .a, .so) without BCOs. If no LinkablePart remains, return Nothing.

partitionLinkables :: [Linkable] -> ([Linkable], [Linkable]) Source #

Split the LinkablePart lists in each Linkable into only object code files (.o, .a, .so) and only byte code, and return two lists containing the nonempty Linkables for each.

data ModuleByteCode Source #

The in-memory representation of a bytecode object These are stored on-disk as .gbc files.

Constructors

ModuleByteCode
Fields gbc_module :: Module gbc_compiled_byte_code :: CompiledByteCode gbc_foreign_files :: [FilePath] Path to object files

Instances

Instances details

Outputable ModuleByteCode Source #
Instance details Defined in GHC.Linker.Types Methods ppr :: ModuleByteCode -> SDoc Source #