Hi all,
Manuel Chakravarty has helped me[1] with getting runtime
importing of modules (a.k.a. dynamic loading) working in GHC on
Linux. It should work on Windows, too.
The concept: You want to have the equivalent of dlopen(); i.e. be
able to tell the Haskell runtime system to import a module and
call functions in that module. As an example, say there's
a function called adder:
module Adder1 where
adder n = n + 2
which you want to call from another module, called, erm, "Main":
module Main where
main = do
-- somehow import the Adder module
let foo = adder 5
putStr (show foo ++ "\n") -- should print out 7
We've managed to get the concept working, and the actual code
isn't all that complex.
We compile the Linker.lhs file (from the compiler/ghci/ directory
in the GHC source) so that we can get access to the functions in
the Haskell Runtime System's linker. Then you can utilise the
FFI to runtime-import the module that you want.
Here's some example code (sorry to make this email so long):
Adder1.hs:
module Adder1 where
foreign export adder :: (Int -> Int)
adder n = n + 2
Adder2.hs:
module Adder2 where
foreign export adder :: (Int -> Int)
adder n = n + 3
Main.hs:
module Main where
import Linker
import Foreign
import Maybe
import System
foreign import dynamic dynCallIntInt :: Ptr (Int -> Int) -> (Int -> Int)
main :: IO ()
main = do
-- initialise the runtime system linker
initLinker
-- Need to load these module so that resolveObjs later doesn't complain
loadObj "/usr/lib/ghc-5.02.2/HSstd.o"
loadObj "/usr/lib/ghc-5.02.2/HSstd_cbits.o"
-- Load the module which we really want to load
argv <- getArgs
moduleName <- case argv of
[args] -> return args
_ -> do
putStrLn "usage: ./a.out Foo,"
putStrLn " where Foo is the module name which contains the adder function"
exitWith (ExitFailure 1)
loadObj (moduleName ++ ".o")
loadObj (moduleName ++ "_stub.o")
putStr ("Loaded " ++ moduleName ++ "\n")
-- Tell the linker to resolve the symbols in the newly-loaded object file
resolvedObjs <- resolveObjs
putStr ("Resolved Object Symbols: " ++ show resolvedObjs ++ "\n")
-- Look up the function name we want to call
foundSymbol <- lookupSymbol "adder"
let justFoundSymbol = fromJust foundSymbol
-- Call the function with appropriate parameters
let result = dynCallIntInt justFoundSymbol 6
putStr (show result ++ "\n")
-- Finished!
putStr "Yay!\n"
.. and the demonstration:
16:25(0) .../project/runtime_import% make
ghc -fglasgow-exts -package lang -c `ghc --print-libdir`/HSrts.o Linker.lhs
ghc -fglasgow-exts -package lang -c `ghc --print-libdir`/HSrts.o Adder1.hs
ghc -fglasgow-exts -package lang -c `ghc --print-libdir`/HSrts.o Adder2.hs
ghc -ldl -package lang -fglasgow-exts -fvia-c Main.hs Linker.o
nice make 6.29s user 0.65s system 94% cpu 7.359 total
16:25(0) .../project/runtime_import% ./a.out Adder1
Loaded Adder1
Resolved Object Symbols: True
8
Yay!
16:25(0) .../project/runtime_import% ./a.out Adder2
Loaded Adder2
Resolved Object Symbols: True
9
Yay!
16:25(0) .../project/runtime_import%
So it looks like it all works nicely :).
The sample code's available at:
http://www.algorithm.com.au/hacking/haskell/
if anybody wants to take a look at it.
1. Okay, he had about 95% of the insight, and I managed to piece
the other 5% together :)
--
#ozone/algorithm