{-# LANGUAGE CPP #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE UnboxedTuples #-} {-# LANGUAGE ForeignFunctionInterface #-} -- NOTE: This file is a copy of System.Plugins.Load. It has been patched to -- expose some internal functionality (loadObjectFile, which used to be part -- of load). When the patch is integrated into the plugins package, this file -- can be removed. -- -- Copyright (C) 2004-5 Don Stewart - http://www.cse.unsw.edu.au/~dons -- -- This library is free software; you can redistribute it and/or -- modify it under the terms of the GNU Lesser General Public -- License as published by the Free Software Foundation; either -- version 2.1 of the License, or (at your option) any later version. -- -- This library is distributed in the hope that it will be useful, -- but WITHOUT ANY WARRANTY; without even the implied warranty of -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -- Lesser General Public License for more details. -- -- You should have received a copy of the GNU Lesser General Public -- License along with this library; if not, write to the Free Software -- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 -- USA -- -- | An interface to the GHC runtime's dynamic linker, providing runtime -- loading and linking of Haskell object files, commonly known as -- /plugins/. module Barley.AltLoad ( -- * The @LoadStatus@ type LoadStatus(..) -- * High-level interface , load , load_ , dynload , pdynload , pdynload_ , unload , unloadAll , reload , Module(..) -- * Low-level interface , initLinker -- start it up , loadObjectFile -- load and resolve a .o and all its dependencies , loadModule -- load a vanilla .o , loadFunction -- retrieve a function from an object , loadFunction_ -- retrieve a function from an object , loadPackageFunction , loadPackage -- load a ghc library and its cbits , unloadPackage -- unload a ghc library and its cbits , loadPackageWith -- load a pkg using the package.conf provided , loadShared -- load a .so object file , resolveObjs -- and resolve symbols , loadRawObject -- load a bare .o. no dep chasing, no .hi file reading , Symbol , getImports ) where -- #include "../../../config.h" import System.Plugins.Make ( build ) import System.Plugins.Env import System.Plugins.Utils import System.Plugins.Consts ( sysPkgSuffix, hiSuf, prefixUnderscore ) import System.Plugins.LoadTypes -- import Language.Hi.Parser import BinIface import HscTypes import Module (moduleName, moduleNameString, packageIdString) import HscMain (newHscEnv) import TcRnMonad (initTcRnIf) import Data.Dynamic ( fromDynamic, Dynamic ) import Data.Typeable ( Typeable ) import Data.List ( isSuffixOf, nub, nubBy ) import Control.Monad ( when, filterM, liftM ) import System.Directory ( doesFileExist, removeFile ) import Foreign.C.String ( CString, withCString, peekCString ) import GHC ( defaultCallbacks ) import GHC.Ptr ( Ptr(..), nullPtr ) import GHC.Exts ( addrToHValue# ) import GHC.Prim ( unsafeCoerce# ) #if DEBUG import System.IO ( hFlush, stdout ) #endif import System.IO ( hClose ) ifaceModuleName :: ModIface -> String ifaceModuleName = moduleNameString . moduleName . mi_module readBinIface' :: FilePath -> IO ModIface readBinIface' hi_path = do -- kludgy as hell e <- newHscEnv defaultCallbacks undefined initTcRnIf 'r' e undefined undefined (readBinIface IgnoreHiWay QuietBinIFaceReading hi_path) -- TODO need a loadPackage p package.conf :: IO () primitive -- -- | The @LoadStatus@ type encodes the return status of functions that -- perform dynamic loading in a type isomorphic to 'Either'. Failure -- returns a list of error strings, success returns a reference to a -- loaded module, and the Haskell value corresponding to the symbol that -- was indexed. -- data LoadStatus a = LoadSuccess Module a | LoadFailure Errors -- -- | 'load' is the basic interface to the dynamic loader. A call to -- 'load' imports a single object file into the caller's address space, -- returning the value associated with the symbol requested. Libraries -- and modules that the requested module depends upon are loaded and -- linked in turn. -- -- The first argument is the path to the object file to load, the second -- argument is a list of directories to search for dependent modules. -- The third argument is a list of paths to user-defined, but -- unregistered, /package.conf/ files. The 'Symbol' argument is the -- symbol name of the value you with to retrieve. -- -- The value returned must be given an explicit type signature, or -- provided with appropriate type constraints such that Haskell compiler -- can determine the expected type returned by 'load', as the return -- type is notionally polymorphic. -- -- Example: -- -- > do mv <- load "Plugin.o" ["api"] [] "resource" -- > case mv of -- > LoadFailure msg -> print msg -- > LoadSuccess _ v -> return v -- load :: FilePath -- ^ object file -> [FilePath] -- ^ any include paths -> [PackageConf] -- ^ list of package.conf paths -> Symbol -- ^ symbol to find -> IO (LoadStatus a) load obj incpaths pkgconfs sym = do m <- loadObjectFile obj incpaths pkgconfs v <- loadFunction m sym return $ case v of Nothing -> LoadFailure ["load: couldn't find symbol <<"++sym++">>"] Just a -> LoadSuccess m a -- -- | Like load, but doesn't want a package.conf arg (they are rarely used) -- load_ :: FilePath -> [FilePath] -> Symbol -> IO (LoadStatus a) load_ o i s = load o i [] s -- -- A work-around for Dynamics. The keys used to compare two TypeReps are -- somehow not equal for the same type in hs-plugin's loaded objects. -- Solution: implement our own dynamics... -- -- The problem with dynload is that it requires the plugin to export -- a value that is a Dynamic (in our case a (TypeRep,a) pair). If this -- is not the case, we core dump. Use pdynload if you don't trust the -- user to supply you with a Dynamic -- dynload :: Typeable a => FilePath -> [FilePath] -> [PackageConf] -> Symbol -> IO (LoadStatus a) dynload obj incpaths pkgconfs sym = do s <- load obj incpaths pkgconfs sym case s of e@(LoadFailure _) -> return e LoadSuccess m dyn_v -> return $ case fromDynamic (unsafeCoerce# dyn_v :: Dynamic) of Just v' -> LoadSuccess m v' Nothing -> LoadFailure ["Mismatched types in interface"] ------------------------------------------------------------------------ -- -- The super-replacement for dynload -- -- Use GHC at runtime so we get staged type inference, providing full -- power dynamics, *on module interfaces only*. This is quite suitable -- for plugins, of coures :) -- -- TODO where does the .hc file go in the call to build() ? -- pdynload :: FilePath -- ^ object to load -> [FilePath] -- ^ include paths -> [PackageConf] -- ^ package confs -> Type -- ^ API type -> Symbol -- ^ symbol -> IO (LoadStatus a) pdynload object incpaths pkgconfs ty sym = do #if DEBUG putStr "Checking types ... " >> hFlush stdout #endif errors <- unify object incpaths [] ty sym #if DEBUG putStrLn "done" #endif if null errors then load object incpaths pkgconfs sym else return $ LoadFailure errors -- -- | Like pdynload, but you can specify extra arguments to the -- typechecker. -- pdynload_ :: FilePath -- ^ object to load -> [FilePath] -- ^ include paths for loading -> [PackageConf] -- ^ any extra package.conf files -> [Arg] -- ^ extra arguments to ghc, when typechecking -> Type -- ^ expected type -> Symbol -- ^ symbol to load -> IO (LoadStatus a) pdynload_ object incpaths pkgconfs args ty sym = do #if DEBUG putStr "Checking types ... " >> hFlush stdout #endif errors <- unify object incpaths args ty sym #if DEBUG putStrLn "done" #endif if null errors then load object incpaths pkgconfs sym else return $ LoadFailure errors ------------------------------------------------------------------------ -- run the typechecker over the constraint file -- -- Problem: if the user depends on a non-auto package to build the -- module, then that package will not be in scope when we try to build -- the module, when performing `unify'. Normally make() will handle this -- (as it takes extra ghc args). pdynload ignores these, atm -- but it -- shouldn't. Consider a pdynload() that accepts extra -package flags? -- -- Also, pdynload() should accept extra in-scope modules. -- Maybe other stuff we want to hack in here. -- unify :: FilePath -> [[Char]] -> [String] -> String -> String -> IO [String] unify obj incs args ty sym = do (tmpf,hdl) <- mkTemp (tmpf1,hdl1) <- mkTemp -- and send .hi file here. hClose hdl1 let nm = mkModid (basename tmpf) src = mkTest nm (hierize' . mkModid . hierize $ obj) (fst $ break (=='.') ty) ty sym is = map ("-i"++) incs -- api i = "-i" ++ dirname obj -- plugin hWrite hdl src e <- build tmpf tmpf1 (i:is++args++["-fno-code","-ohi "++tmpf1]) mapM_ removeFile [tmpf,tmpf1] return e where -- fix up hierarchical names hierize [] = [] hierize ('/':cs) = '\\' : hierize cs hierize (c:cs) = c : hierize cs hierize'[] = [] hierize' ('\\':cs) = '.' : hierize' cs hierize' (c:cs) = c : hierize' cs mkTest :: String -> String -> String -> String -> String -> String mkTest modnm plugin api ty sym = "module "++ modnm ++" where" ++ "\nimport qualified " ++ plugin ++ "\nimport qualified " ++ api ++ "{-# LINE 1 \"\" #-}" ++ "\n_ = "++ plugin ++"."++ sym ++" :: "++ty ------------------------------------------------------------------------ {- -- -- old version that tried to rip stuff from .hi files -- pdynload obj incpaths pkgconfs sym ty = do (m, v) <- load obj incpaths pkgconfs sym ty' <- mungeIface sym obj if ty == ty' then return $ Just (m, v) else return Nothing -- mismatched types where -- grab the iface output from GHC. find the line relevant to our -- symbol. grab the string rep of the type. mungeIface sym o = do let hi = replaceSuffix o hiSuf (out,_) <- exec ghc ["--show-iface", hi] case find (\s -> (sym ++ " :: ") `isPrefixOf` s) out of Nothing -> return undefined Just v -> do let v' = drop 3 $ dropWhile (/= ':') v return v' -} {- -- -- a version of load the also unwraps and types a Dynamic object -- dynload2 :: Typeable a => FilePath -> FilePath -> Maybe [PackageConf] -> Symbol -> IO (Module, a) dynload2 obj incpath pkgconfs sym = do (m, v) <- load obj incpath pkgconfs sym case fromDynamic v of Nothing -> panic $ "load: couldn't type "++(show v) Just a -> return (m,a) -} ------------------------------------------------------------------------ -- -- | unload a module (not its dependencies) -- we have the dependencies, so cascaded unloading is possible -- -- once you unload it, you can't 'load' it again, you have to 'reload' -- it. Cause we don't unload all the dependencies -- unload :: Module -> IO () unload m = rmModuleDeps m >> unloadObj m ------------------------------------------------------------------------ -- -- | unload a module and its dependencies -- we have the dependencies, so cascaded unloading is possible -- unloadAll :: Module -> IO () unloadAll m = do moduleDeps <- getModuleDeps m rmModuleDeps m mapM_ unloadAll moduleDeps unload m -- -- | this will be nice for panTHeon, needs thinking about the interface -- reload a single object file. don't care about depends, assume they -- are loaded. (should use state to store all this) -- -- assumes you've already done a 'load' -- -- should factor the code -- reload :: Module -> Symbol -> IO (LoadStatus a) reload m@(Module{path = p, iface = hi}) sym = do unloadObj m -- unload module (and delete) #if DEBUG putStr ("Reloading "++(mname m)++" ... ") >> hFlush stdout #endif m_ <- loadObject p . Object . ifaceModuleName $ hi -- load object at path p let m' = m_ { iface = hi } resolveObjs (unloadAll m) #if DEBUG putStrLn "done" >> hFlush stdout #endif v <- loadFunction m' sym return $ case v of Nothing -> LoadFailure ["load: couldn't find symbol <<"++sym++">>"] Just a -> LoadSuccess m' a -- -- This is a stripped-down version of Andre Pang's runtime_loader, -- which in turn is based on GHC's ghci\/ObjLinker.lhs binding -- -- Load and unload\/Haskell modules at runtime. This is not really -- \'dynamic loading\', as such -- that implies that you\'re working -- with proper shared libraries, whereas this is far more simple and -- only loads object files. But it achieves the same goal: you can -- load a Haskell module at runtime, load a function from it, and run -- the function. I have no idea if this works for types, but that -- doesn\'t mean that you can\'t try it :). -- -- read $fptools\/ghc\/compiler\/ghci\/ObjLinker.lhs for how to use this stuff -- -- | Call the initLinker function first, before calling any of the other -- functions in this module - otherwise you\'ll get unresolved symbols. -- initLinker :: IO () -- our initLinker transparently calls the one in GHC -- -- | This is a mid-level interface to the dynamic loader. A call to -- 'loadObjectFile' imports a single object file into the caller's address, -- space returning the 'Module' associated with it. Libraries and modules that -- the requested module depends upon are loaded and linked in turn. -- -- The first argument is the path to the object file to load, the second -- argument is a list of directories to search for dependent modules. -- The third argument is a list of paths to user-defined, but -- unregistered, /package.conf/ files. loadObjectFile :: FilePath -- ^ object file -> [FilePath] -- ^ any include paths -> [PackageConf] -- ^ list of package.conf paths -> IO Module loadObjectFile obj incpaths pkgconfs = do initLinker -- load extra package information mapM_ addPkgConf pkgconfs (hif,moduleDeps) <- loadDepends obj incpaths -- why is this the package name? #if DEBUG putStr (' ':(decode $ ifaceModuleName hif)) >> hFlush stdout #endif m' <- loadObject obj . Object . ifaceModuleName $ hif let m = m' { iface = hif } resolveObjs (mapM_ unloadAll (m:moduleDeps)) #if DEBUG putStrLn " ... done" >> hFlush stdout #endif addModuleDeps m' moduleDeps return m -- -- | Load a function from a module (which must be loaded and resolved first). -- loadFunction :: Module -- ^ The module the value is in -> String -- ^ Symbol name of value -> IO (Maybe a) -- ^ The value you want loadFunction (Module { iface = i }) valsym = loadFunction_ (ifaceModuleName i) valsym loadFunction_ :: String -> String -> IO (Maybe a) loadFunction_ = loadFunction__ Nothing loadFunction__ :: Maybe String -> String -> String -> IO (Maybe a) loadFunction__ pkg m valsym = do let symbol = prefixUnderscore++(maybe "" (\p -> encode p++"_") pkg) ++encode m++"_"++(encode valsym)++"_closure" #if DEBUG putStrLn $ "Looking for <<"++symbol++">>" #endif ptr@(Ptr addr) <- withCString symbol c_lookupSymbol if (ptr == nullPtr) then return Nothing else case addrToHValue# addr of (# hval #) -> return ( Just hval ) -- | Loads a function from a package module, given the package name, -- module name and symbol name. loadPackageFunction :: String -- ^ Package name, including version number. -> String -- ^ Module name -> String -- ^ Symbol to lookup in the module -> IO (Maybe a) loadPackageFunction pkgName modName functionName = do loadPackage pkgName resolveObjs (unloadPackage pkgName) loadFunction__ (Just pkgName) modName functionName -- -- | Load a GHC-compiled Haskell vanilla object file. -- The first arg is the path to the object file -- -- We make it idempotent to stop the nasty problem of loading the same -- .o twice. Also the rts is a very special package that is already -- loaded, even if we ask it to be loaded. N.B. we should insert it in -- the list of known packages. -- -- NB the environment stores the *full path* to an object. So if you -- want to know if a module is already loaded, you need to supply the -- *path* to that object, not the name. -- -- NB -- let's try just the module name. -- -- loadObject loads normal .o objs, and packages too. .o objs come with -- a nice canonical Z-encoded modid. packages just have a simple name. -- Do we want to ensure they won't clash? Probably. -- -- -- the second argument to loadObject is a string to use as the unique -- identifier for this object. For normal .o objects, it should be the -- Z-encoded modid from the .hi file. For archives\/packages, we can -- probably get away with the package name -- loadObject :: FilePath -> Key -> IO Module loadObject p ky@(Object k) = loadObject' p ky k loadObject p ky@(Package k) = loadObject' p ky k loadObject' :: FilePath -> Key -> String -> IO Module loadObject' p ky k | ("HSrts"++sysPkgSuffix) `isSuffixOf` p = return (emptyMod p) | otherwise = do alreadyLoaded <- isLoaded k when (not alreadyLoaded) $ do r <- withCString p c_loadObj when (not r) (panic $ "Could not load module `"++p++"'") addModule k (emptyMod p) -- needs to Z-encode module name return (emptyMod p) where emptyMod q = Module q (mkModid q) Vanilla undefined ky -- -- load a single object. no dependencies. You should know what you're -- doing. -- loadModule :: FilePath -> IO Module loadModule obj = do let hifile = replaceSuffix obj hiSuf exists <- doesFileExist hifile if (not exists) then error $ "No .hi file found for "++show obj else do hiface <- readBinIface' hifile loadObject obj (Object (ifaceModuleName hiface)) -- -- | Load a generic .o file, good for loading C objects. -- You should know what you're doing.. -- Returns a fairly meaningless iface value. -- loadRawObject :: FilePath -> IO Module loadRawObject obj = loadObject obj (Object k) where k = encode (mkModid obj) -- Z-encoded module name -- -- | Resolve (link) the modules loaded by the 'loadObject' function. -- resolveObjs :: IO a -> IO () resolveObjs unloadLoaded = do r <- c_resolveObjs when (not r) $ unloadLoaded >> panic "resolvedObjs failed." -- | Unload a module unloadObj :: Module -> IO () unloadObj (Module { path = p, kind = k, key = ky }) = case k of Vanilla -> withCString p $ \c_p -> do removed <- rmModule name when (removed) $ do r <- c_unloadObj c_p when (not r) (panic "unloadObj: failed") Shared -> return () -- can't unload .so? where name = case ky of Object s -> s ; Package pk -> pk -- -- | from ghci\/ObjLinker.c -- -- Load a .so type object file. -- loadShared :: FilePath -> IO Module loadShared str = do #if DEBUG putStrLn $ " shared: " ++ str #endif maybe_errmsg <- withCString str $ \dll -> c_addDLL dll if maybe_errmsg == nullPtr then return (Module str (mkModid str) Shared undefined (Package (mkModid str))) else do e <- peekCString maybe_errmsg panic $ "loadShared: couldn't load `"++str++"\' because "++e -- -- Load a -package that we might need, implicitly loading the cbits too -- The argument is the name of package (e.g. \"concurrent\") -- -- How to find a package is determined by the package.conf info we store -- in the environment. It is just a matter of looking it up. -- -- Not printing names of dependent pkgs -- loadPackage :: String -> IO () loadPackage p = do #if DEBUG putStr (' ':p) >> hFlush stdout #endif (libs,dlls) <- lookupPkg p mapM_ (\l -> loadObject l (Package (mkModid l))) libs #if DEBUG putStr (' ':show libs) >> hFlush stdout putStr (' ':show dlls) >> hFlush stdout #endif mapM_ loadShared dlls -- -- Unload a -package, that has already been loaded. Unload the cbits -- too. The argument is the name of the package. -- -- May need to check if it exists. -- -- Note that we currently need to unload everything. grumble grumble. -- -- We need to add the version number to the package name with 6.4 and -- over. "yi-0.1" for example. This is a bug really. -- unloadPackage :: String -> IO () unloadPackage pkg = do let pkg' = takeWhile (/= '-') pkg -- in case of *-0.1 libs <- liftM (\(a,_) -> (filter (isSublistOf pkg') ) a) (lookupPkg pkg) flip mapM_ libs $ \p -> withCString p $ \c_p -> do r <- c_unloadObj c_p when (not r) (panic "unloadObj: failed") rmModule (mkModid p) -- unrecord this module -- -- load a package using the given package.conf to help -- TODO should report if it doesn't actually load the package, instead -- of mapM_ doing nothing like above. -- loadPackageWith :: String -> [PackageConf] -> IO () loadPackageWith p pkgconfs = do #if DEBUG putStr "Loading package" >> hFlush stdout #endif mapM_ addPkgConf pkgconfs loadPackage p #if DEBUG putStrLn " done" #endif -- --------------------------------------------------------------------- -- module dependency loading -- -- given an Foo.o vanilla object file, supposed to be a plugin compiled -- by our library, find the associated .hi file. If this is found, load -- the dependencies, packages first, then the modules. If it doesn't -- exist, assume the user knows what they are doing and continue. The -- linker will crash on them anyway. Second argument is any include -- paths to search in -- -- ToDo problem with absolute and relative paths, and different forms of -- relative paths. A user may cause a dependency to be loaded, which -- will search the incpaths, and perhaps find "./Foo.o". The user may -- then explicitly load "Foo.o". These are the same, and the loader -- should ignore the second load request. However, isLoaded will say -- that "Foo.o" is not loaded, as the full string is used as a key to -- the modenv fm. We need a canonical form for the keys -- is basename -- good enough? -- loadDepends :: FilePath -> [FilePath] -> IO (ModIface,[Module]) loadDepends obj incpaths = do let hifile = replaceSuffix obj hiSuf exists <- doesFileExist hifile if (not exists) then do #if DEBUG putStrLn "No .hi file found." >> hFlush stdout #endif return (undefined,[]) -- could be considered fatal else do hiface <- readBinIface' hifile let ds = mi_deps hiface -- remove ones that we've already loaded ds' <- filterM loaded . map (moduleNameString . fst) . dep_mods $ ds -- now, try to generate a path to the actual .o file -- fix up hierachical names let mods_ = map (\s -> (s, map (\c -> if c == '.' then '/' else c) $ s)) ds' -- construct a list of possible dependent modules to load let mods = concatMap (\p -> map (\(hi,m) -> (hi,p m++".o")) mods_) incpaths -- remove modules that don't exist mods' <- filterM (\(_,y) -> doesFileExist y) $ nubBy (\v u -> snd v == snd u) mods -- now remove duplicate valid paths to the same object let mods'' = nubBy (\v u -> fst v == fst u) mods' -- and find some packages to load, as well. let ps = dep_pkgs ds ps' <- filterM loaded . map packageIdString . nub $ ps #if DEBUG when (not (null ps')) $ putStr "Loading package" >> hFlush stdout #endif mapM_ loadPackage ps' #if DEBUG when (not (null ps')) $ putStr " ... linking ... " >> hFlush stdout #endif resolveObjs (mapM_ unloadPackage ps') #if DEBUG when (not (null ps')) $ putStrLn "done" putStr "Loading object" mapM_ (\(m,_) -> putStr (" "++ m) >> hFlush stdout) mods'' #endif moduleDeps <- mapM (\(hi,m) -> loadObject m (Object hi)) mods'' return (hiface,moduleDeps) -- --------------------------------------------------------------------- -- Nice interface to .hi parser -- getImports :: String -> IO [String] getImports m = do hi <- readBinIface' (m ++ hiSuf) return . map (moduleNameString . fst) . dep_mods . mi_deps $ hi -- --------------------------------------------------------------------- -- C interface -- foreign import ccall safe "lookupSymbol" c_lookupSymbol :: CString -> IO (Ptr a) foreign import ccall unsafe "loadObj" c_loadObj :: CString -> IO Bool foreign import ccall unsafe "unloadObj" c_unloadObj :: CString -> IO Bool foreign import ccall unsafe "resolveObjs" c_resolveObjs :: IO Bool foreign import ccall unsafe "addDLL" c_addDLL :: CString -> IO CString foreign import ccall unsafe "initLinker" initLinker :: IO ()