Utilisation de `import import prim` avec une fonction C utilisant la convention d'appel STG

Question

J'ai une routine C simple qui prend quatre mots et retourne quatre mots, et pour lequel gcc peut optimiser et émettre des primops que GHC ne supporte pas. J'essaie de comparer différentes façons d'appeler cette procédure, et j'ai du mal à essayer d'adapter la technique described here pour utiliser foreign import prim.

Ce qui suit est juste pour ajouter 1 à chaque mot d'entrée, mais segfaults.

Main.hs:

{-# LANGUAGE GHCForeignImportPrim #-} 
{-# LANGUAGE ForeignFunctionInterface #-} 
{-# LANGUAGE MagicHash #-} 
{-# LANGUAGE UnboxedTuples #-} 
{-# LANGUAGE UnliftedFFITypes #-} 
import Foreign.C 
import GHC.Prim 
import GHC.Int 
import GHC.Word 

foreign import prim "sipRound" 
    sipRound_c# :: Word# -> Word# -> Word# -> Word# -> (# Word#, Word#, Word#, Word# #) 

sipRound_c :: Word64 -> Word64 -> Word64 -> Word64 -> (Word64, Word64, Word64, Word64) 
sipRound_c (W64# v0) (W64# v1) (W64# v2) (W64# v3) = case sipRound_c# v0 v1 v2 v3 of 
    (# v0', v1', v2', v3' #) -> (W64# v0', W64# v1', W64# v2', W64# v3') 

main = do 
    print $ sipRound_c 1 2 3 4 

sip.c:

#include <stdlib.h> 
#include <stdint.h> 
#include <stdbool.h> 



// define a function pointer type that matches the STG calling convention 
typedef void (*HsCall)(int64_t*, int64_t*, int64_t*, int64_t, int64_t, int64_t, int64_t, 
         int64_t, int64_t, int64_t*, float, float, float, float, double, double); 

extern void 
sipRound(
    int64_t* restrict baseReg, 
    int64_t* restrict sp, 
    int64_t* restrict hp, 

    uint64_t v0, // R1 
    uint64_t v1, // R2 
    uint64_t v2, // R3 
    uint64_t v3, // R4 
    int64_t r5, 
    int64_t r6, 

    int64_t* restrict spLim, 
    float f1, 
    float f2, 
    float f3, 
    float f4, 
    double d1, 
    double d2) 
{ 

    v0 += 1; 
    v1 += 1; 
    v2 += 1; 
    v3 += 1; 

    // create undefined variables, clang will emit these as a llvm undef literal 
    const int64_t iUndef; 
    const float fUndef; 
    const double dUndef; 

    const HsCall fun = (HsCall)sp[0]; 
    return fun(
      baseReg, 
      sp, 
      hp, 

      v0, 
      v1, 
      v2, 
      v3, 
      iUndef, 
      iUndef, 

      spLim, 
      fUndef, 
      fUndef, 
      fUndef, 
      fUndef, 
      dUndef, 
      dUndef); 
} 

Je ne sais pas vraiment ce que je fais. Existe-t-il un moyen d'adapter la technique à partir de ce blog? Et est-ce une mauvaise idée?

Answer 1

Si vous êtes prêt à écrire à la main, vous pouvez le faire comme ceci (pour x86_64). Mettez ceci dans un fichier avec une extension .s et fournissez-le comme argument sur la ligne de commande ghc.

.global sipRound 
sipRound: 
    inc %rbx 
    inc %r14 
    inc %rsi 
    inc %rdi 
    jmp *(%rbp) 

La mise en correspondance entre les registres du STG et les registres de la machine est défini dans https://github.com/ghc/ghc/blob/master/includes/stg/MachRegs.h#L159. Notez qu'il y aura toujours un appel de fonction impliqué, donc il ne sera pas aussi efficace que le code que vous obtenez de LLVM.