@ccall library.function_name(argvalue1::argtype1, ...)::returntype
@ccall function_name(argvalue1::argtype1, ...)::returntype
@ccall $function_pointer(argvalue1::argtype1, ...)::returntype

Appeler une fonction dans une bibliothèque partagée exportée par C, spécifiée par library.function_name, où library est une constante ou un littéral de chaîne. La bibliothèque peut être omise, auquel cas le function_name est résolu dans le processus actuel. Alternativement, @ccall peut également être utilisé pour appeler un pointeur de fonction $function_pointer, tel que celui retourné par dlsym.

Chaque argvalue à @ccall est converti en argtype correspondant, par insertion automatique d'appels à unsafe_convert(argtype, cconvert(argtype, argvalue)). (Voir aussi la documentation pour unsafe_convert et cconvert pour plus de détails.) Dans la plupart des cas, cela se traduit simplement par un appel à convert(argtype, argvalue).

Exemples

@ccall strlen(s::Cstring)::Csize_t

Cela appelle la fonction de la bibliothèque standard C :

size_t strlen(char *)

avec une variable Julia nommée s. Voir aussi ccall.

Les varargs sont pris en charge avec la convention suivante :

@ccall printf("%s = %d"::Cstring ; "foo"::Cstring, foo::Cint)::Cint

Le point-virgule est utilisé pour séparer les arguments requis (dont il doit y avoir au moins un) des arguments variadiques.

Exemple utilisant une bibliothèque externe :

# Signature C de g_uri_escape_string:
# char *g_uri_escape_string(const char *unescaped, const char *reserved_chars_allowed, gboolean allow_utf8);

const glib = "libglib-2.0"
@ccall glib.g_uri_escape_string(my_uri::Cstring, ":/"::Cstring, true::Cint)::Cstring

Le littéral de chaîne pourrait également être utilisé directement avant le nom de la fonction, si désiré "libglib-2.0".g_uri_escape_string(...

ccall((nom_fonction, bibliothèque), type_retour, (type_arg1, ...), valeur_arg1, ...)
ccall(nom_fonction, type_retour, (type_arg1, ...), valeur_arg1, ...)
ccall(pointeur_fonction, type_retour, (type_arg1, ...), valeur_arg1, ...)

Appelle une fonction dans une bibliothèque partagée exportée en C, spécifiée par le tuple (nom_fonction, bibliothèque), où chaque composant est soit une chaîne de caractères, soit un symbole. Au lieu de spécifier une bibliothèque, on peut également utiliser un symbole ou une chaîne de caractères nom_fonction, qui est résolu dans le processus actuel. Alternativement, ccall peut également être utilisé pour appeler un pointeur de fonction pointeur_fonction, tel que celui retourné par dlsym.

Notez que le tuple de types d'arguments doit être un tuple littéral, et non une variable ou une expression de type tuple.

Chaque valeur_arg pour le ccall sera convertie au type argtype correspondant, par insertion automatique d'appels à unsafe_convert(argtype, cconvert(argtype, valeur_arg)). (Voir aussi la documentation pour unsafe_convert et cconvert pour plus de détails.) Dans la plupart des cas, cela se traduit simplement par un appel à convert(argtype, valeur_arg).

cglobal((symbol, library) [, type=Cvoid])

Obtenez un pointeur vers une variable globale dans une bibliothèque partagée exportée en C, spécifiée exactement comme dans ccall. Renvoie un Ptr{Type}, par défaut Ptr{Cvoid} si aucun argument Type n'est fourni. Les valeurs peuvent être lues ou écrites par unsafe_load ou unsafe_store!, respectivement.

@cfunction(callable, ReturnType, (ArgumentTypes...,)) -> Ptr{Cvoid}
@cfunction($callable, ReturnType, (ArgumentTypes...,)) -> CFunction

Générez un pointeur de fonction appelable en C à partir de la fonction Julia callable pour la signature de type donnée. Pour passer la valeur de retour à un ccall, utilisez le type d'argument Ptr{Cvoid} dans la signature.

Notez que le tuple de types d'argument doit être un tuple littéral, et non une variable ou une expression de type tuple (bien qu'il puisse inclure une expression splat). Et ces arguments seront évalués dans le scope global pendant le temps de compilation (et non différés jusqu'à l'exécution). Ajouter un '$' devant l'argument de fonction change cela pour créer plutôt une fermeture d'exécution sur la variable locale callable (ceci n'est pas supporté sur toutes les architectures).

Voir section du manuel sur l'utilisation de ccall et cfunction.

Exemples

julia> function foo(x::Int, y::Int)
           return x + y
       end

julia> @cfunction(foo, Int, (Int, Int))
Ptr{Cvoid} @0x000000001b82fcd0

CFunction struct

Gestion de la collecte des déchets pour la valeur de retour de @cfunction lorsque le premier argument est annoté avec '$'. Comme tous les handles cfunction, il doit être passé à ccall en tant que Ptr{Cvoid}, et sera converti automatiquement au site d'appel au type approprié.

Voir @cfunction.

unsafe_convert(T, x)

Convertir x en un argument C de type T où l'entrée x doit être la valeur de retour de cconvert(T, ...).

Dans les cas où convert devrait prendre un objet Julia et le transformer en un Ptr, cette fonction doit être utilisée pour définir et effectuer cette conversion.

Soyez prudent pour vous assurer qu'une référence Julia à x existe tant que le résultat de cette fonction sera utilisé. En conséquence, l'argument x de cette fonction ne doit jamais être une expression, seulement un nom de variable ou une référence de champ. Par exemple, x=a.b.c est acceptable, mais x=[a,b,c] ne l'est pas.

Le préfixe unsafe sur cette fonction indique que l'utilisation du résultat de cette fonction après que l'argument x de cette fonction ne soit plus accessible au programme peut entraîner un comportement indéfini, y compris la corruption du programme ou des segfaults, à tout moment ultérieur.

Voir aussi cconvert

cconvert(T,x)

Convertir x en une valeur à passer au code C en tant que type T, généralement en appelant convert(T, x).

Dans les cas où x ne peut pas être converti en toute sécurité en T, contrairement à convert, cconvert peut renvoyer un objet d'un type différent de T, qui est cependant adapté pour que unsafe_convert puisse le gérer. Le résultat de cette fonction doit rester valide (pour le GC) jusqu'à ce que le résultat de unsafe_convert ne soit plus nécessaire. Cela peut être utilisé pour allouer de la mémoire qui sera accessible par le ccall. Si plusieurs objets doivent être alloués, un tuple des objets peut être utilisé comme valeur de retour.

Ni convert ni cconvert ne devraient prendre un objet Julia et le transformer en un Ptr.

unsafe_load(p::Ptr{T}, i::Integer=1)
unsafe_load(p::Ptr{T}, order::Symbol)
unsafe_load(p::Ptr{T}, i::Integer, order::Symbol)

Charge une valeur de type T à partir de l'adresse du i-ème élément (indexé à partir de 1) commençant à p. Cela équivaut à l'expression C p[i-1]. En option, un ordre de mémoire atomique peut être fourni.

Le préfixe unsafe sur cette fonction indique qu'aucune validation n'est effectuée sur le pointeur p pour s'assurer qu'il est valide. Comme en C, le programmeur est responsable de s'assurer que la mémoire référencée n'est pas libérée ou collectée par le ramasse-miettes lors de l'invocation de cette fonction. Une utilisation incorrecte peut provoquer un segfault dans votre programme ou retourner des réponses indésirables. Contrairement à C, le déréférencement d'une région de mémoire allouée comme un type différent peut être valide à condition que les types soient compatibles.

Voir aussi : atomic

unsafe_store!(p::Ptr{T}, x, i::Integer=1)
unsafe_store!(p::Ptr{T}, x, order::Symbol)
unsafe_store!(p::Ptr{T}, x, i::Integer, order::Symbol)

Stocke une valeur de type T à l'adresse du i-ème élément (indexé à partir de 1) commençant à p. Cela équivaut à l'expression C p[i-1] = x. En option, un ordre de mémoire atomique peut être fourni.

Le préfixe unsafe sur cette fonction indique qu'aucune validation n'est effectuée sur le pointeur p pour s'assurer qu'il est valide. Comme en C, le programmeur est responsable de s'assurer que la mémoire référencée n'est pas libérée ou collectée par le ramasse-miettes pendant l'invocation de cette fonction. Une utilisation incorrecte peut provoquer un segfault dans votre programme. Contrairement à C, stocker une région de mémoire allouée comme un type différent peut être valide à condition que les types soient compatibles.

Voir aussi : atomic

unsafe_modify!(p::Ptr{T}, op, x, [order::Symbol]) -> Pair

Ces opérations effectuent de manière atomique les opérations pour obtenir et définir une adresse mémoire après avoir appliqué la fonction op. Si cela est pris en charge par le matériel (par exemple, l'incrémentation atomique), cela peut être optimisé vers l'instruction matérielle appropriée, sinon son exécution sera similaire à :

y = unsafe_load(p)
z = op(y, x)
unsafe_store!(p, z)
return y => z

Le préfixe unsafe sur cette fonction indique qu'aucune validation n'est effectuée sur le pointeur p pour s'assurer qu'il est valide. Comme en C, le programmeur est responsable de s'assurer que la mémoire référencée n'est pas libérée ou collectée par le ramasse-miettes lors de l'invocation de cette fonction. Une utilisation incorrecte peut provoquer un segfault dans votre programme.

Voir aussi : modifyproperty!, atomic

unsafe_replace!(p::Ptr{T}, expected, desired,
               [success_order::Symbol[, fail_order::Symbol=success_order]]) -> (; old, success::Bool)

Ces opérations effectuent de manière atomique les opérations pour obtenir et conditionnellement définir une adresse mémoire à une valeur donnée. Si cela est pris en charge par le matériel, cela peut être optimisé pour l'instruction matérielle appropriée, sinon son exécution sera similaire à :

y = unsafe_load(p, fail_order)
ok = y === expected
if ok
    unsafe_store!(p, desired, success_order)
end
return (; old = y, success = ok)

Le préfixe unsafe sur cette fonction indique qu'aucune validation n'est effectuée sur le pointeur p pour s'assurer qu'il est valide. Comme en C, le programmeur est responsable de s'assurer que la mémoire référencée n'est pas libérée ou collectée par le ramasse-miettes lors de l'invocation de cette fonction. Une utilisation incorrecte peut provoquer un segfault dans votre programme.

Voir aussi : replaceproperty!, atomic

unsafe_swap!(p::Ptr{T}, x, [order::Symbol])

Ces opérations effectuent atomiquement les opérations pour obtenir et définir simultanément une adresse mémoire. Si cela est pris en charge par le matériel, cela peut être optimisé pour l'instruction matérielle appropriée, sinon son exécution sera similaire à :

y = unsafe_load(p)
unsafe_store!(p, x)
return y

Le préfixe unsafe sur cette fonction indique qu'aucune validation n'est effectuée sur le pointeur p pour s'assurer qu'il est valide. Comme en C, le programmeur est responsable de s'assurer que la mémoire référencée n'est pas libérée ou collectée par le ramasse-miettes lors de l'invocation de cette fonction. Une utilisation incorrecte peut provoquer un segfault dans votre programme.

Voir aussi : swapproperty!, atomic

unsafe_copyto!(dest::Ptr{T}, src::Ptr{T}, N)

Copie N éléments d'un pointeur source vers une destination, sans vérification. La taille d'un élément est déterminée par le type des pointeurs.

Le préfixe unsafe sur cette fonction indique qu'aucune validation n'est effectuée sur les pointeurs dest et src pour s'assurer qu'ils sont valides. Une utilisation incorrecte peut corrompre ou provoquer un segfault dans votre programme, de la même manière qu'en C.

unsafe_copyto!(dest::Array, do, src::Array, so, N)

Copie N éléments d'un tableau source vers un tableau de destination, en commençant à l'index linéaire so dans la source et do dans la destination (indexé à partir de 1).

Le préfixe unsafe sur cette fonction indique qu'aucune validation n'est effectuée pour s'assurer que N est dans les limites des deux tableaux. Une utilisation incorrecte peut corrompre ou provoquer un segfault dans votre programme, de la même manière que C.

copyto!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
        tM::AbstractChar,
        M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B

Copier efficacement les éléments de la matrice M vers B en fonction du paramètre de caractère tM comme suit :

Les éléments B[ir_dest, jr_dest] sont écrasés. De plus, les paramètres de plage d'index doivent satisfaire length(ir_dest) == length(ir_src) et length(jr_dest) == length(jr_src).

Voir aussi copy_transpose! et copy_adjoint!.

copyto!(dest::AbstractMatrix, src::UniformScaling)

Copie un UniformScaling dans une matrice.

copyto!(dest, do, src, so, N)

Copie N éléments de la collection src en commençant à l'index linéaire so, vers le tableau dest en commençant à l'index do. Retourne dest.

copyto!(dest::AbstractArray, src) -> dest

Copie tous les éléments de la collection src vers le tableau dest, dont la longueur doit être supérieure ou égale à la longueur n de src. Les premiers n éléments de dest sont écrasés, les autres éléments restent inchangés.

Voir aussi copy!, copy.

Exemples

julia> x = [1., 0., 3., 0., 5.];

julia> y = zeros(7);

julia> copyto!(y, x);

julia> y
7-element Vector{Float64}:
 1.0
 0.0
 3.0
 0.0
 5.0
 0.0
 0.0

copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest

Copie le bloc de src dans la plage de Rsrc vers le bloc de dest dans la plage de Rdest. Les tailles des deux régions doivent correspondre.

Exemples

julia> A = zeros(5, 5);

julia> B = [1 2; 3 4];

julia> Ainds = CartesianIndices((2:3, 2:3));

julia> Binds = CartesianIndices(B);

julia> copyto!(A, Ainds, B, Binds)
5×5 Matrix{Float64}:
 0.0  0.0  0.0  0.0  0.0
 0.0  1.0  2.0  0.0  0.0
 0.0  3.0  4.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0

pointer(array [, index])

Obtenez l'adresse native d'un tableau ou d'une chaîne, éventuellement à un emplacement donné index.

Cette fonction est "non sécurisée". Faites attention à vous assurer qu'une référence Julia à array existe tant que ce pointeur sera utilisé. Le macro GC.@preserve doit être utilisé pour protéger l'argument array de la collecte des ordures dans un bloc de code donné.

Appeler Ref(array[, index]) est généralement préférable à cette fonction car cela garantit la validité.

unsafe_wrap(Array, pointer::Ptr{T}, dims; own = false)

Enveloppez un objet Array de Julia autour des données à l'adresse donnée par pointer, sans faire de copie. Le type d'élément du pointeur T détermine le type d'élément du tableau. dims est soit un entier (pour un tableau 1d) soit un tuple des dimensions du tableau. own spécifie en option si Julia doit prendre possession de la mémoire, en appelant free sur le pointeur lorsque le tableau n'est plus référencé.

Cette fonction est étiquetée "unsafe" car elle plantera si pointer n'est pas une adresse mémoire valide pour des données de la longueur demandée. Contrairement à unsafe_load et unsafe_store!, le programmeur est également responsable de s'assurer que les données sous-jacentes ne sont pas accessibles par deux tableaux de types d'éléments différents, similaire à la règle d'aliasage strict en C.

pointer_from_objref(x)

Obtenez l'adresse mémoire d'un objet Julia sous forme de Ptr. L'existence du Ptr résultant ne protégera pas l'objet de la collecte des ordures, vous devez donc vous assurer que l'objet reste référencé pendant toute la durée d'utilisation du Ptr.

Cette fonction ne peut pas être appelée sur des objets immuables, car ils n'ont pas d'adresses mémoire stables.

Voir aussi unsafe_pointer_to_objref.

unsafe_pointer_to_objref(p::Ptr)

Convertit un Ptr en une référence d'objet. Supposons que le pointeur fasse référence à un objet Julia valide alloué sur le tas. Si ce n'est pas le cas, un comportement indéfini en résulte, c'est pourquoi cette fonction est considérée comme "dangereuse" et doit être utilisée avec précaution.

Voir aussi pointer_from_objref.

disable_sigint(f::Function)

Désactive le gestionnaire Ctrl-C pendant l'exécution d'une fonction sur la tâche actuelle, pour appeler du code externe qui peut appeler du code julia qui n'est pas sûr pour les interruptions. Destiné à être appelé en utilisant la syntaxe de bloc do comme suit :

disable_sigint() do
    # code non sûr pour les interruptions
    ...
end

Cela n'est pas nécessaire sur les threads de travail (Threads.threadid() != 1) puisque l'InterruptException ne sera livrée qu'au thread maître. Les fonctions externes qui n'appellent pas de code julia ou le runtime julia désactivent automatiquement sigint pendant leur exécution.

reenable_sigint(f::Function)

Réactive le gestionnaire Ctrl-C pendant l'exécution d'une fonction. Inverse temporairement l'effet de disable_sigint.

exit_on_sigint(on::Bool)

Définir le drapeau exit_on_sigint de l'environnement d'exécution Julia. Si false, Ctrl-C (SIGINT) est capturable comme InterruptException dans un bloc try. C'est le comportement par défaut dans REPL, tout code exécuté via -e et -E et dans un script Julia exécuté avec l'option -i.

Si true, InterruptException n'est pas lancé par Ctrl-C. L'exécution de code lors d'un tel événement nécessite atexit. C'est le comportement par défaut dans un script Julia exécuté sans l'option -i.

systemerror(sysfunc[, errno::Cint=Libc.errno()])
systemerror(sysfunc, iftrue::Bool)

Lève une SystemError pour errno avec la chaîne descriptive sysfunc si iftrue est true

windowserror(sysfunc[, code::UInt32=Libc.GetLastError()])
windowserror(sysfunc, iftrue::Bool)

Comme systemerror, mais pour les fonctions de l'API Windows qui utilisent GetLastError pour retourner un code d'erreur au lieu de définir errno.

Ptr{T}

Une adresse mémoire faisant référence à des données de type T. Cependant, il n'y a aucune garantie que la mémoire soit réellement valide, ou qu'elle représente réellement des données du type spécifié.

Ref{T}

Un objet qui référence en toute sécurité des données de type T. Ce type est garanti de pointer vers une mémoire valide, allouée par Julia, du type correct. Les données sous-jacentes sont protégées de la libération par le ramasse-miettes tant que le Ref lui-même est référencé.

En Julia, les objets Ref sont déréférencés (chargés ou stockés) avec [].

La création d'un Ref pour une valeur x de type T s'écrit généralement Ref(x). De plus, pour créer des pointeurs intérieurs vers des conteneurs (comme Array ou Ptr), cela peut s'écrire Ref(a, i) pour créer une référence à l'élément i-ème de a.

Ref{T}() crée une référence à une valeur de type T sans initialisation. Pour un type de bits T, la valeur sera ce qui réside actuellement dans la mémoire allouée. Pour un type non-bit T, la référence sera indéfinie et tenter de la déréférencer entraînera une erreur, "UndefRefError: accès à une référence indéfinie".

Pour vérifier si un Ref est une référence indéfinie, utilisez isassigned(ref::RefValue). Par exemple, isassigned(Ref{T}()) est false si T n'est pas un type de bits. Si T est un type de bits, isassigned(Ref{T}()) sera toujours vrai.

Lorsqu'il est passé comme argument ccall (soit en tant que type Ptr ou Ref), un objet Ref sera converti en un pointeur natif vers les données qu'il référence. Pour la plupart des T, ou lorsqu'il est converti en Ptr{Cvoid}, il s'agit d'un pointeur vers les données de l'objet. Lorsque T est un type isbits, cette valeur peut être mutée en toute sécurité, sinon la mutation est strictement un comportement indéfini.

Dans un cas particulier, définir T = Any entraînera plutôt la création d'un pointeur vers la référence elle-même lorsqu'il est converti en Ptr{Any} (un jl_value_t const* const* si T est immuable, sinon un jl_value_t *const *). Lorsqu'il est converti en Ptr{Cvoid}, il renverra toujours un pointeur vers la région de données comme pour tout autre T.

Une instance C_NULL de Ptr peut être passée à un argument ccall Ref pour l'initialiser.

Utilisation dans le broadcasting

Ref est parfois utilisé dans le broadcasting afin de traiter les valeurs référencées comme un scalaire.

Exemples

julia> r = Ref(5) # Créer un Ref avec une valeur initiale
Base.RefValue{Int64}(5)

julia> r[] # Obtenir une valeur d'un Ref
5

julia> r[] = 7 # Stocker une nouvelle valeur dans un Ref
7

julia> r # Le Ref contient maintenant 7
Base.RefValue{Int64}(7)

julia> isa.(Ref([1,2,3]), [Array, Dict, Int]) # Traiter les valeurs de référence comme des scalaires lors du broadcasting
BitVector de 3 éléments :
 1
 0
 0

julia> Ref{Function}()  # Référence indéfinie à un type non-bit, Function
Base.RefValue{Function}(#undef)

julia> try
           Ref{Function}()[] # Déréférencer une référence indéfinie entraînera une erreur
       catch e
           println(e)
       end
UndefRefError()

julia> Ref{Int64}()[]; # Une référence à un type de bits fait référence à une valeur indéterminée si non donnée

julia> isassigned(Ref{Int64}()) # Une référence à un type de bits est toujours assignée
true

isassigned(ref::RefValue) -> Bool

Testez si le Ref donné est associé à une valeur. Cela est toujours vrai pour un Ref d'un objet de type bitstype. Retournez false si la référence est indéfinie.

Exemples

julia> ref = Ref{Function}()
Base.RefValue{Function}(#undef)

julia> isassigned(ref)
false

julia> ref[] = (foobar(x) = x)
foobar (generic function with 1 method)

julia> isassigned(ref)
true

julia> isassigned(Ref{Int}())
true

Cchar

Équivalent au type c natif char.

Cuchar

Équivalent au type c natif unsigned char (UInt8).

Cshort

Équivalent au type c natif signed short (Int16).

Cstring

Une chaîne de caractères de style C composée du type de caractère natif Cchar. Les Cstring sont terminées par un NUL. Pour les chaînes de caractères de style C composées du type de caractère large natif, voir Cwstring. Pour plus d'informations sur l'interopérabilité des chaînes avec C, voir le manuel.

Cushort

Équivalent au type c natif unsigned short (UInt16).

Cint

Équivalent au type c natif signed int (Int32).

Cuint

Équivalent au type c natif unsigned int (UInt32).

Clong

Équivalent au type c natif signed long.

Culong

Équivalent au type c natif unsigned long.

Clonglong

Équivalent au type C natif signed long long (Int64).

Culonglong

Équivalent au type c natif unsigned long long (UInt64).

Cintmax_t

Équivalent au type c natif intmax_t (Int64).

Cuintmax_t

Équivalent au type c natif uintmax_t (UInt64).

Csize_t

Équivalent au type c natif size_t (UInt).

Cssize_t

Équivalent au type c natif ssize_t.

Cptrdiff_t

Équivalent au type c natif ptrdiff_t (Int).

Cwchar_t

Équivalent au type c natif wchar_t (Int32).

Cwstring

Une chaîne de caractères de style C composée du type de caractère large natif Cwchar_t. Les Cwstring sont terminées par un NUL. Pour les chaînes de caractères de style C composées du type de caractère natif, voir Cstring. Pour plus d'informations sur l'interopérabilité des chaînes avec C, voir le manuel.

Cfloat

Équivalent au type c natif float (Float32).

Cdouble

Équivalent au type c natif double (Float64).

llvmcall(fun_ir::String, returntype, Tuple{argtype1, ...}, argvalue1, ...)
llvmcall((mod_ir::String, entry_fn::String), returntype, Tuple{argtype1, ...}, argvalue1, ...)
llvmcall((mod_bc::Vector{UInt8}, entry_fn::String), returntype, Tuple{argtype1, ...}, argvalue1, ...)

Appelez le code LLVM fourni dans le premier argument. Il existe plusieurs façons de spécifier ce premier argument :

• comme une chaîne littérale, représentant le IR au niveau de la fonction (similaire à un bloc define LLVM), avec des arguments disponibles sous forme de variables SSA non nommées (%0, %1, etc.) ;
• comme un tuple de 2 éléments, contenant une chaîne de IR de module et une chaîne représentant le nom de la fonction d'entrée à appeler ;
• comme un tuple de 2 éléments, mais avec le module fourni sous forme de Vector{UInt8} avec du bitcode.

Notez qu'à la différence de ccall, les types d'arguments doivent être spécifiés comme un type de tuple, et non comme un tuple de types. Tous les types, ainsi que le code LLVM, doivent être spécifiés comme des littéraux, et non comme des variables ou des expressions (il peut être nécessaire d'utiliser @eval pour générer ces littéraux).

Les pointeurs opaques (écrits comme ptr) ne sont pas autorisés dans le code LLVM.

Voir test/llvmcall.jl pour des exemples d'utilisation.