使用 FFI 的可执行文件是否需要 GHC 选项？

Question

我在Main.hs 中有一个模块Main。该程序使用 FFI（特别是 FunPtr）。

当我运行 stack exec ghci 并加载模块 (:l src/Main.hs) 时，它运行良好。

但是，当我将模块编译为可执行文件并运行该可执行文件时，我遇到了崩溃，即分段错误。

因此我想知道是否需要使用某个选项进行编译。处理 FFI 时是否有特定的选项可供使用？我试过-O0，-fllvm，没办法。也许stack exec ghci 包含一个可以与 GHC 一起使用的选项？

另外，是否有一个调试选项可以设置为 GHC 以便使用 gdb 运行可执行文件？我尝试了-g 选项，但gdb 没有找到调试符号。 EDIT这点解决了：gdb在我用stack exec -- ghc -g -rtsopts src/Main.hs编译的时候找到调试符号。

我在 Linux Ubuntu 上使用 GHC 8.2.2。

编辑

这是一个反映我真实程序结构的最小程序。这个工作正常（在 GHCI 中或作为可执行文件），但我仍然包含它。

helloffi.c：

#include <stdlib.h>

double** evalf(double (*f)(double), double x){
    double** out = malloc(2 * sizeof(double*));
    for(unsigned i=0; i<2; i++){
        out[i] = malloc(2 * sizeof(double));
        out[i][0] = (*f)(x);
        out[i][1] = (*f)(x+1);
    }
    return out;
}

double sumpointer(double** pptr){
    double x=0;
    for(unsigned i=0; i<2; i++){
        for(unsigned j=0; j<2; j++){
            x += pptr[i][j];
        }
    }
    return x;
}

库的主模块，Lib.hs

{-# LANGUAGE ForeignFunctionInterface #-}
module Lib
  where
import           Foreign.C.Types       
import           Foreign.Ptr           (Ptr, FunPtr, freeHaskellFunPtr)

type CFunction = CDouble -> IO CDouble

foreign import ccall "wrapper" functionPtr 
    :: CFunction -> IO (FunPtr CFunction)

foreign import ccall "evalf" c_evalf
    :: FunPtr CFunction
    -> CDouble
    -> IO (Ptr (Ptr CDouble))

fun2cfun :: (Double -> Double) -> CFunction
fun2cfun f x = 
    return $ realToFrac (f (realToFrac x))

evalFun :: (Double -> Double) -> Double -> IO (Ptr (Ptr CDouble))
evalFun f x = do
    fPtr <- functionPtr (fun2cfun f)
    result <- c_evalf fPtr (realToFrac x)
    freeHaskellFunPtr fPtr
    return result

foreign import ccall "sumpointer" c_sumpointer
    :: Ptr (Ptr CDouble) -> IO CDouble

要编译的模块 Main.hs

module Main
  where
import           Lib

main :: IO ()
main = do
    x <- evalFun (\x -> x*x) 2
    y <- c_sumpointer x
    print y

Answer 1

嗯，这并不是问题的真正答案，但我已经痛苦地解决了这个问题，我认为它可能对其他人有所帮助。值得分享。所以我发布了一个显示问题的最小示例。一个非常简单的例子。

helloffi/
├── C
│   ├── array.c
│   ├── helloffi.c
│   └── helloffi.h
├── helloffi.cabal
├── Setup.hs
├── src
│   ├── Lib.hs
│   └── Main.hs
└── stack.yaml

array.c：在C文件中定义一个数组，例如：

int array[2][3] =  
    {{1, 24, 1},
     {2, 19, 1}};

helloffi.c：定义一个使用这个数组的函数，例如：

#include "helloffi.h"

int getCoef(unsigned i, unsigned j){
    return array[i][j];
}

helloffi.h，头文件：

int array[2][3];
int getCoef(unsigned, unsigned);

这就是 C 部分的全部内容。现在是 Haskell 部分。制作一个库模块，导入 C 函数。

Lib.hs：

{-# LANGUAGE ForeignFunctionInterface #-}
module Lib
  where
import           Foreign.C.Types       

foreign import ccall "getCoef" c_getCoef
    :: CUInt -> CUInt -> IO CInt

Main.hs，编译成可执行文件：

module Main
  where
import           Lib

main :: IO ()
main = do
    x <- c_getCoef 0 1
    print x

就是这样。而现在，谜团。编译库（获取模块Lib和Main.hs生成的可执行文件，假设这个叫做test）。

stack exec ghci，给出正确的结果（24）：

Prelude> :l src/Main.hs 
[1 of 1] Compiling Main             ( src/Main.hs, interpreted )
Ok, one module loaded.
*Main> main
24

运行可执行文件，给出错误结果（总是0）：

$ .stack-work/install/x86_64-linux/lts-11.4/8.2.2/bin/test 
0

test 可执行文件是编译后的Main.hs。但是它没有正确读取array.c 中的数组条目，而:l src/Main.hs 在stack exec ghci 之后给出了正确的结果。

是不是很奇怪？有没有人解释一下？

解决方案

我还不知道为什么stack exec ghci 和可执行文件之间的行为会有所不同，但现在有了@Alec 的以下cmets 的解决方案：将头文件中的int array[2][3] 替换为extern int array[2][3] 就足够了。看起来可执行文件将int array[2][3] 视为array 的定义，其条目初始化为0，而stack exec ghci 将其视为array 的声明。