- FFI - Haskell.org

FFI, DLL Linking, Windows Haskell Platform 2010
by Nabil Alsharif 30 Mar '11

30 Mar '11

Hi Everybody, So, like every one else on this list, I have a C library that I would like to access form Haskell. I am in the process of writing a Haskell interface for the distorm3 disassembler. The library was compiled into a DLL using MSVC. Because this is the first I've used FFI I'm keeping it simple and there is only one function I import Ala: foreign import ccall "distorm.h distorm_version" c_distorm_version :: IO (CUInt) The issue is when I try to compile the library the linker goes haywire: C:\Users\tantalum\Documents\Research\distorm_test>ghc --make Main.hs [2 of 2] Compiling Main ( Main.hs, Main.o ) Linking Main.exe ... .\Distorm3.o:fake:(.text+0x11b): undefined reference to `distorm_version' collect2: ld returned 1 exit status C:\Users\tantalum\Documents\Research\distorm_test>ghc --make Main.hs -l distorm3 Linking Main.exe ... C:\Program Files (x86)\Haskell Platform\2010.2.0.0\mingw\bin\ld.exe: cannot find -lC:\Users\tantalum\AppData\Local\Temp\ghc5976_0\ghc5976_0.o collect2: ld returned 1 exit status Any ideas or suggestions? What is that temporary object file for? Thanks in advance for any help. Hope you all are having a good day. Nabil Alsharif.

1 0

don't get a correct memory address at a getter Method
by Nick Rudnick 28 Aug '10

28 Aug '10

Hi, being new to the FFI, I hope this might have an easy solution: The following (GHC 6.12.1), ---------------------- C++ lib class A { public: B* getB(){ B* ptr= &b; cerr << "C: " << << endl; return ptr; } private: B b; } ---------------------- C wrapper B* A_getB(A* a){ a->getB(); } ---------------------- Haskell lib foreign import ccall unsafe "A_getB" a_getB:: APtr-> IO BPtr ... getB = a_getB ---------------------- Haskell app b <-getB a putStrLn ("HS: "++show b) ---------------------- leads to deviated pointer addresses, e.g., ... C: 0x19bc808 HS: 0x00007fa92f812c80 ... Do you know a solution? Am I doing something wrong? Thanks in advance, Nick

2 1

Import, how to
by grzyb 19 Jul '10

19 Jul '10

Hi, I'm a beginner at haskell and ffi. I was trying to import and use is haskell one C function, but I can't manage to do that. Can someone show me an example how to create an import and a use example for such a C function: char functionName(char *, unsigned int, char *) -- View this message in context: http://old.nabble.com/Import%2C-how-to-tp29199694p29199694.html Sent from the Haskell - FFI mailing list archive at Nabble.com.

3 2

addFinalizer to which object? (fwd from cafe)
by Henning Thielemann 22 Jan '10

22 Jan '10

The documentation of System.Mem.Weak.addFinalizer suggests to me, that this function is very fragile, because the object we track, might be optimized away. In my case this applies. I have a resource that is needed for generating chunks of a lazy byte string. If the byte string is created completely or the byte string cannot be accessed anymore, this resource must be freed. It must also be freed within Haskell code, thus addForeignPtrFinalizer does not help. To illustrate that I have attached a small example, where I use a StablePtr as resource, that points to a list. This Haskell list is read from C code and written to a chunk of a lazy ByteString. A Haskell function creates the ByteString lazily and calls the C function for every new chunk. I have added a finalizer to the StablePtr itself. That works without optimization, but using optimization the finalizer is run immediately and the program aborts with segmentation fault. Thus my question: How to get reliable finalization? #include "ProcessList_stub.h" /* The function copies elements from a Haskell list to a piece of memory and returns the number of bytes that could be fetched. */ int copy_list_to_chunk (unsigned long int n, HsStablePtr list, char *p) { unsigned long int k = n; while (k>0) { if (!get_next_element(list, p)) {break; } p++; k--; } return (n-k); } {- # generate C stubs ghc -c ProcessList.hs # generate executable ghc -O --make ProcessChunk.c ProcessList.hs -} {- Use a C function for filling chunks of a lazy ByteString with data from a Haskell list. A StablePtr is needed to pass the list to C and back to Haskell. Somehow we must assert that the StablePtr is deleted and the list can be garbage collected, once the ByteString is constructed. We concatenate infinitely many such lists, thus many StablePtrs and referenced lists must be freed. Use addFinalizer? To which object shall I add the finalizer? Without optimization adding the finalizer to the StablePtr works, with optimization, its finalizer is run too early. I also tried to add the finalizer to the end of the list, which is not quite correct, but then the finalizer is run never. Whatever I tried: Finalizer is run immediately or never. What is the right way? -} {-# LANGUAGE ForeignFunctionInterface #-} module Main where import qualified Data.ByteString as B import qualified Data.ByteString.Internal as BI import qualified Data.ByteString.Lazy as BL import qualified Data.ByteString.Lazy.Internal as BLI import System.IO.Unsafe (unsafePerformIO, unsafeInterleaveIO, ) import System.Mem.Weak (addFinalizer, ) import Foreign.StablePtr (StablePtr, newStablePtr, freeStablePtr, deRefStablePtr, ) import Foreign.Storable (poke, ) import Foreign.C.Types (CULong, ) import Foreign.Ptr (FunPtr, Ptr, nullPtr, castPtr, ) import Data.IORef (IORef, newIORef, readIORef, writeIORef, ) import Data.Word (Word8, Word32, ) import Control.Monad (liftM2, ) getNextElement :: StablePtr (IORef [Word8]) -> Ptr Word8 -> IO Bool getNextElement stable elemPtr = do listRef <- deRefStablePtr stable xt <- readIORef listRef case xt of [] -> return False x:xs -> do poke elemPtr x writeIORef listRef xs return True foreign export ccall "get_next_element" getNextElement :: StablePtr (IORef [Word8]) -> Ptr Word8 -> IO Bool foreign import ccall "copy_list_to_chunk" copyListToChunk :: CULong -> StablePtr (IORef [Word8]) -> Ptr Word8 -> IO CULong chunkSize :: Int chunkSize = 13 byteStringFromList :: [Word8] -> BL.ByteString byteStringFromList list = unsafePerformIO $ do stable <- newStablePtr =<< newIORef list addFinalizer stable (putStrLn "free stable pointer" >> freeStablePtr stable) let go = unsafeInterleaveIO $ do v <- BI.createAndTrim chunkSize $ fmap fromIntegral . copyListToChunk (fromIntegral chunkSize) stable fmap (BLI.chunk v) $ if B.length v < chunkSize then return BL.empty else go go main :: IO () main = print $ BL.unpack $ -- BL.take 1000 $ BL.concat $ map (BL.take 42 . byteStringFromList . iterate (1+)) (iterate (1+) 0)

1 1

advancePtr for ForeignPtr
by Henning Thielemann 20 Feb '09

20 Feb '09

I want to have an advancePtr on ForeignPtr in order create a subarray. Is this reasonable and possible? Do I have to use 'touchForeignPtr' as finalizer of the subarray's ForeignPtr in order to assert that the superarray lives at least as long as the subarray? Anyway I'd prefer a function in the standard modules than doing such things by myself.

1 0

Re: building and analysing C structs with Storable
by John Meacham 15 Oct '07

15 Oct '07

On Sun, Oct 14, 2007 at 09:28:45PM +0200, Henning Thielemann wrote: > >You say "the system's C compiler" as if there was only one. It's quite > >common for UNIXoid systems to have several C compilers installed > >simultaneously; and if you use the module corresponding to the wrong > >compiler, you get silent data loss. I wouldn't risk it. > > Do different C compilers on the same platform actually use different > layouts for structs? If yes, how can I find out, with which compiler a > library was compiled? Not in general, the exact layout of C structs and whatnot is set forth in the ABI spec developed by the chip manufacturer. All compilers must follow it or they cannot even use the same libraries. that said, some compilers out there do sometimes deviate from the ABI, or allow it as an option, but there is generally an accepted ABI for a OS-platform pair. Otherwise things like 'libc' would not be abled to be linked against. for instance the ABI for x86-64 is here http://www.x86-64.org/documentation/abi-0.98.pdf John -- John Meacham - ⑆repetae.net⑆john⑈

1 0

Re: Force single evaluation?
by Axel Jantsch 21 Dec '06

21 Dec '06

I tried both alternatives: foreign import ccall originalFn :: Arg1T -> Arg2T -> IO ResultT foreign import ccall originalFn :: Arg1T -> Arg2T -> ResultT but in both cases the C function originalFn is called several times for the same arguments. And it is bound only in one place. I don't understand why. Maybe the problem is that the data marshaling has to be done within the monad? My simplified codes is as follows: f :: InparT -> IO CInt f inPar = do inP <- malloc poke inP inPar r <- cfun inP free inP return r foreign import ccall "cfun" :: Ptr InparT -> IO CInt So even if I make cfun pure (which it is), the enclosing function f is not. Shall I pretend f is pure and wrap it into unsafePerformIO? Regards, Axel Malcolm Wallace <Malcolm.Wallace(a)cs.york.ac.uk> wrote: > "Axel Jantsch" <axel(a)kth.se> wrote: > > > I call a C function from a Haskell program. I am using unsafePerformIO > > to use it outside a monad. > > > > Even though the C function does not have any side effect, I absolutely > > don't want to evaluate it more than once for performance reasons. But > > my impression is that it is evaluated several times. > > > > 1. Can I monitor somehow how often it is evaluated? > > You could wrap it (in C) with another function that keeps a counter of > invocations in a static local variable. > > result_t originalFn (arg1_t arg1, arg2_t arg2); > result_t wrappedFn (arg1_t arg1, arg2_t arg2) { > static int i = 0; > i++; > fprintf(stderr,"originalFn called %d times\n",i); > return originalFn(arg1,arg2); > } > > > 2. Can I ensure that the function is evaluated only once? > > How about stating in the type of the FFI decl that the C function is > pure (even if it is not)? Then be sure to bind its result in only one > place. That should guarantee it is called only once. > > foreign import ccall originalFn :: Arg1T -> Arg2T -> IO ResultT > becomes > foreign import ccall originalFn :: Arg1T -> Arg2T -> ResultT > > Regards, > Malcolm > _______________________________________________ > FFI mailing list > FFI(a)haskell.org > http://www.haskell.org/mailman/listinfo/ffi > -- Phone: +46 8 790 4124, Email: axel(a)kth.se, Web: www.it.kth.se/~axel

2 1

Force single evaluation?
by Axel Jantsch 19 Dec '06

19 Dec '06

Hello, I call a C function from a Haskell program. I am using unsafePerformIO to use it outside a monad. Even though the C function does not have any side effect, I absolutely don't want to evaluate it more than once for performance reasons. But my impression is that it is evaluated several times. 1. Can I monitor somehow how often it is evaluated? 2. Can I ensure that the function is evaluated only once? I am using ghc 6.4.1 I ma grateful for any hint! Regards, Axel -- Phone: +46 8 790 4124, Email: axel(a)kth.se, Web: www.it.kth.se/~axel -- --- Phone: +46 8 790 4124, Email: axel(a)imit.kth.se, Web: www.imit.kth.se/~axel

2 1

struct and tuples
by Axel Jantsch 21 Jun '06

21 Jun '06

Hi, I thought I wanted something very simple but just cannot find out how to do it; I assume I am overlooking something very obvious. I want to hand over a tuple to a C function and get a tuple back: type myTup = (Bool, Int) myFun :: myTup -> myTup So myFun should be implemented as a C function and I thought I use a struct to represent the tuple: typedef struct myStruct { int b; int x; }; struct myStruct myCFun (struct myStruct); I tried to use c2hs, looked at the documentation of ffi, c2hs, greenCard, hsc2h s, the mail archives etc. but I somehow I cannot figure out how to do it. Do I have to use Ptr? Do I have to make myTup an instance of Storable? Or? I greatly appreciate any hint! -- Axel -- Phone: +46 8 790 4124, Email: axel(a)kth.se, Web: www.it.kth.se/~axel

1 0

FFI docs
by Simon Peyton-Jones 16 Apr '06

16 Apr '06

Manuel A couple of comments about the FFI spec. I was trying to find out whether the automatic newtype unwrapping for 'foreign' declarations was part of the FFI spec. I searched for 'newtype'. Nothing. Turns out that the *only* reference is in the sentence in 3.2: "The argument types ati produced by fatype must be marshallable foreign types; that is, each ati is either (1) a basic foreign type or (2) a type synonym or renamed datatype of a marshallable foreign type." This is very quiet! The "renamed datatype" nomenclature is never used in practice (only in the Haskell report), and in any case the sentence is hard to unpick without an example or two. Second point. Consider foreign import "dynamic" foo :: (Int -> IO Int) -> ... I'm not sure whether (Int -> IO Int) is considered a "marshallable foreign type", according to the defn in 3.2. I also found the separation of 4.1.3 from 3.2 quite hard to understand. I was searching in 3.2 for "wrapper" and "dynamic" in vain! I don't have a good solution to this, except perhaps some explicit fwd refs, and a clear explanation of the logic behind the structure of the document. Since some aspects of the FFI spec may change slightly for Haskell', this seemed like a good moment to mention these points. Simon

2 1