GHCi doesn't work with FFI export declarations/shared libraries

Question

I have a problem regarding FFI in Haskell and the interactive mode of GHC. (Source is also available via a gist): FFISo.hs: ``` {-# LANGUAGE OverloadedStrings #-} {-# LANGUAGE ForeignFunctionInterface #-} module Main where import qualified Data.ByteString.Char8 as B foreign import ccall "callMeFromHaskell" callMeFromHaskell :: IO () foreign export ccall callMeFromC :: IO () callMeFromC :: IO () callMeFromC = B.putStrLn "callMeFromC" main :: IO () main = do B.putStrLn "main" callMeFromHaskell return () ``` c.c: ``` #include <stdio.h> void callMeFromC(void); void callMeFromHaskell(void) { printf("callMeFromHaskell
"); callMeFromC(); } ``` Makefile: ``` GHC_OPT := -Wall -O2 -fno-warn-unused-do-bind all: ffiso test: ffiso ./$< ffiso: FFISo.hs c.c ghc --make $(GHC_OPT) $^ -o $@ clean: rm -rf *.hi *.o ffiso *_stub.* ghci0: ffiso echo main | ghci FFISo.hs ghci1: ffiso echo main | ghci FFISo.hs c.o ghci2: ffiso echo main | ghci FFISo.hs c.o FFISo.o ``` Compiling and linking works fine: ``` $…

Accepted Answer

You need to specify some more objects to link when invoking GHCi, because the C object `c.o` is particularly picky when it comes to linking order.

First, you need to add the `bytestring` package's object files. This is done by adding `-package bytestring` to the GHCi command line.

Then, you need to add the actual object file that defines `callMeFromC`. When `FFISo.hs` is compiled, it doesn't produce an object file that exports `callMeFromC`. It instead uses the GHC naming convention and exports `Main_zdfcallMeFromCzuak4_closure`, which actually is a static global variable pointing to the closure/"thunk" that contains the actual function definition and environment. This is so that you can't write something like this:

```
foregin export ccall foo :: IO ()
foo = undefined
```

...and have the runtime crash as soon as the program starts because the "function value" of `foo` can't be evaluated. The function definition is only inspected once the function is actually used.

GHC generates a stub file, which contains C code for calling the Haskell function from C. This file is called `FFISo_stub.c`, and is compiled into `FFISo_stub.o` for you. This object file exports the "C version" of `callMeFromC` that can be called directly. Feel free to inspect the generated code, it is quite interesting.

All in all, you need to use this command line when invoking GHCi:

```
ghci -package bytestring FFISo.o c.o FFISo_stub.o FFISo.hs
```

GHCi doesn't work with FFI export declarations/shared libraries

Solution

Problem