C Interface

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

library.function_nameで指定された、C形式でエクスポートされた共有ライブラリ内の関数を呼び出します。libraryは文字列定数または文字列リテラルです。ライブラリは省略できます。その場合、function_nameは現在のプロセス内で解決されます。また、@ccallを使って、dlsymなどが返す関数ポインター$function_pointerを呼び出すこともできます。

argvalueから@ccallまでの各引数は、unsafe_convert(argtype, cconvert(argtype, argvalue))の呼び出しが自動的に挿入され、対応するargtypeに変換されます。(詳しくは、unsafe_convertおよびcconvertのドキュメントも参照してください。)ほとんどの場合、これは単にconvert(argtype, argvalue)の呼び出しになります。

Examples

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

これは、C標準ライブラリ関数を呼び出します。

size_t strlen(char *)

Juliaの変数名sを使います。ccallも参照してください。

可変長引数は、次の規則でサポートされます。

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

セミコロンは、必須引数(少なくとも1つ必要)と可変長引数を区切るために使います。

外部ライブラリを使う例:

# C signature of 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

必要であれば、関数名の直前に文字列リテラルを直接指定することもできます"libglib-2.0".g_uri_escape_string(...

gc_safe = trueオプションを使うと、ccallをgc_safeとして宣言できます。

@ccall gc_safe=true strlen(s::Cstring)::Csize_t

これにより、ccallの実行中にガベージコレクターを並行して動作させることができます。これは、ccallがJuliaの外部でブロックする可能性がある場合に便利です。

Warning

ccallがJuliaランタイムをコールバックする場合、未定義の動作につながる可能性があるため、このオプションは慎重に使用してください。ただし、@cfunction/@ccallablesは安全です。

Julia 1.12

gc_safe引数にはJulia 1.12以降が必要です。

source
ccall — Keyword
ccall((function_name, library), returntype, (argtype1, ...), argvalue1, ...)
ccall(function_name, returntype, (argtype1, ...), argvalue1, ...)
ccall(function_pointer, returntype, (argtype1, ...), argvalue1, ...)

C からエクスポートされた共有ライブラリ内の関数を呼び出します。関数は、各要素が文字列またはシンボルであるタプル (function_name, library) で指定します。ライブラリを指定する代わりに、現在のプロセス内で解決されるシンボルまたは文字列 function_name を指定することもできます。また、ccall を使って、関数ポインター function_pointer を呼び出すこともできます。たとえば、dlsym が返すポインターを指定できます。

引数の型タプルはリテラルでなければなりません。タプル値を持つ変数や式は指定できません。

ccall に渡す各 argvalue は、unsafe_convert(argtype, cconvert(argtype, argvalue)) の呼び出しが自動的に挿入され、対応する argtype に変換されます。(詳しくは、unsafe_convert および cconvert のドキュメントも参照してください。)ほとんどの場合、これは単に convert(argtype, argvalue) の呼び出しになります。

source
Core.Intrinsics.cglobal — Function
cglobal((symbol, library) [, type=Cvoid])

C でエクスポートされた共有ライブラリ内のグローバル変数へのポインターを取得します。指定方法は ccall と同じです。Type 引数が指定されていない場合は、デフォルトで Ptr{Cvoid} となる Ptr{Type} を返します。値の読み取りと書き込みには、それぞれ unsafe_load と unsafe_store! を使用できます。

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

指定した型シグネチャに対して、Julia 関数 callable から C から呼び出し可能な関数ポインターを生成します。戻り値を ccall に渡すには、シグネチャで引数型 Ptr{Cvoid} を使用します。

引数型のタプルはリテラルでなければならず、タプル値を持つ変数や式は使用できません(ただし、スプラット式を含めることはできます)。また、これらの引数は実行時まで評価が遅延されるのではなく、コンパイル時にグローバルスコープで評価されます。関数引数の前に「$」を付けると、代わりにローカル変数 callable をキャプチャする実行時クロージャーが生成されます(すべてのアーキテクチャでサポートされているわけではありません)。

manual section on ccall and cfunction usage を参照してください。

Examples

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

julia> @cfunction(foo, Int, (Int, Int))
Ptr{Cvoid} @0x000000001b82fcd0
source
Base.CFunction — Type
CFunction struct

第1引数に「$」が付いている場合に、@cfunctionの戻り値を保持するためのガベージコレクション用ハンドルです。ほかのcfunctionハンドルと同様に、ccallにはPtr{Cvoid}として渡してください。呼び出し箇所で適切な型に自動変換されます。

@cfunctionを参照してください。

source
Base.unsafe_convert — Function
unsafe_convert(T, x)

xを、T型のC引数に変換します。このとき、入力のxは、cconvert(T, ...)の戻り値でなければなりません。

convertでJuliaオブジェクトをPtrに変換する必要がある場合は、この関数を使って変換を定義し、実行します。

この関数の結果を使用する間は、xへのJulia参照が存在し続けるようにしてください。そのため、この関数の引数xには式を指定せず、変数名またはフィールド参照だけを指定してください。たとえば、x=a.b.cは使用できますが、x=[a,b,c]は使用できません。

この関数名のunsafeという接頭辞は、この関数のx引数にプログラムからアクセスできなくなった後に関数の結果を使用すると、後の時点でプログラムの破損やセグメンテーション違反などの未定義動作が発生する可能性があることを示します。

関連項目: cconvert

source
Base.cconvert — Function
cconvert(T,x)

xを、通常はconvert(T, x)を呼び出して、CコードにT型として渡す値に変換します。

xをTに安全に変換できない場合、convertとは異なり、cconvertはTとは異なる型のオブジェクトを返すことがあります。ただし、そのオブジェクトはunsafe_convertで扱うのに適しています。この関数の戻り値は、unsafe_convertの戻り値が不要になるまで、有効な状態(GCの対象にならない状態)に保つ必要があります。これを利用して、ccallからアクセスされるメモリを確保できます。複数のオブジェクトを確保する必要がある場合は、それらのオブジェクトをタプルにまとめて戻り値にできます。

convertもcconvertも、Juliaオブジェクトを受け取ってPtrに変換してはなりません。

source
Base.unsafe_load — Function
unsafe_load(p::Ptr{T}, i::Integer=1)
unsafe_load(p::Ptr{T}, order::Symbol)
unsafe_load(p::Ptr{T}, i::Integer, order::Symbol)

pから始まる、i番目(1始まり)の要素のアドレスから、型Tの値を読み込みます。これはCの式p[i-1]と同等です。オプションで、アトミックなメモリ順序を指定できます。

この関数名の接頭辞unsafeは、ポインターpが有効かどうかの検証を行わないことを示します。Cと同様に、この関数の呼び出し中に参照先のメモリが解放されたり、ガベージコレクションされたりしないようにする責任はプログラマーにあります。誤った使い方をすると、プログラムがセグフォルトを起こしたり、無意味な値を返したりする可能性があります。一方、Cとは異なり、型に互換性があれば、別の型として確保されたメモリ領域を参照しても有効な場合があります。

Julia 1.10

order引数はJulia 1.10以降で使用できます。

関連項目: atomic

source
Base.unsafe_store! — Function
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)

pから数えてi番目(1始まり)の要素のアドレスに、型がTの値を格納します。これはCの式p[i-1] = xと同等です。必要に応じて、アトミックなメモリ順序を指定できます。

この関数名の接頭辞unsafeは、ポインターpが有効かどうかの検証を行わないことを示します。Cと同様に、この関数の呼び出し中に参照先のメモリが解放されたり、ガベージコレクションされたりしないようにする責任はプログラマーにあります。誤った使い方をすると、プログラムがセグフォルトを起こす可能性があります。Cとは異なり、異なる型として確保されたメモリ領域への格納も、型に互換性があれば有効な場合があります。

Julia 1.10

order引数はJulia 1.10以降で使用できます。

関連項目: atomic

source
Base.unsafe_modify! — Function
unsafe_modify!(p::Ptr{T}, op, x, [order::Symbol])::Pair

これらの関数は、関数 op を適用したうえで、メモリアドレスの値を取得・設定する操作をアトミックに実行します。ハードウェアが対応している場合(アトミックなインクリメントなど)は、適切なハードウェア命令に最適化されることがあります。対応していない場合、実行は次のようになります。

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

この関数の unsafe プレフィックスは、ポインター p が有効かどうかの検証を行わないことを示します。C と同様に、この関数の呼び出し中に参照先のメモリが解放されたり、ガベージコレクションされたりしないようにする責任はプログラマーにあります。誤った使い方をすると、プログラムがセグフォルトを起こす可能性があります。

Julia 1.10

この関数を使用するには、Julia 1.10 以降が必要です。

関連項目: modifyproperty!、atomic

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

これらの関数は、メモリアドレスの値を取得し、条件に応じて指定した値に設定する操作をアトミックに実行します。ハードウェアが対応している場合は、適切なハードウェア命令に最適化されることがあります。対応していない場合、実行は次のようになります。

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

この関数名の接頭辞unsafeは、ポインターpが有効かどうかの検証を行わないことを示しています。Cと同様に、この関数の呼び出し中に参照先のメモリが解放されたり、ガベージコレクションされたりしないようにする責任はプログラマーにあります。誤った使い方をすると、プログラムがセグフォルトを起こす可能性があります。

Julia 1.10

この関数を使用するには、Julia 1.10以降が必要です。

関連項目: replaceproperty!、atomic

source
Base.unsafe_swap! — Function
unsafe_swap!(p::Ptr{T}, x, [order::Symbol])

これらの関数は、メモリアドレスの取得と設定を同時にアトミックに実行します。ハードウェアが対応している場合は、適切なハードウェア命令に最適化されます。対応していない場合、実行は次のようになります。

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

この関数の接頭辞 unsafe は、ポインター p が有効かどうかの検証を行わないことを示します。C と同様に、この関数の呼び出し中に参照先のメモリが解放されたり、ガベージコレクションされたりしないようにする責任はプログラマーにあります。誤った使い方をすると、プログラムがセグフォルトを起こす可能性があります。

Julia 1.10

この関数を使用するには、Julia 1.10 以降が必要です。

関連項目: swapproperty!、atomic

source
Base.unsafe_copyto! — Method
unsafe_copyto!(dest::Ptr{T}, src::Ptr{T}, N)

ソースポインターから宛先へ、N 個の要素をチェックなしでコピーします。要素のサイズは、ポインターの型によって決まります。

この関数に付く unsafe という接頭辞は、ポインター dest と src が有効かどうかを検証しないことを示します。誤った使い方をすると、C と同様に、プログラムのデータが破損したり、セグメンテーション違反が発生したりする可能性があります。

source
Base.unsafe_copyto! — Method
unsafe_copyto!(dest::Array, doffs, src::Array, soffs, n)

ソース配列の線形インデックス soffs から、コピー先配列の線形インデックス doffs(いずれも1始まり)へ、n 個の要素をコピーします。

この関数名の先頭にある unsafe は、n がどちらの配列の範囲内にあるかを検証しないことを示します。誤った使い方をすると、C と同様に、プログラムのメモリが破損したり、セグメンテーション違反が発生したりする可能性があります。

source
Base.copyto! — Function
copyto!(dest, Rdest::CartesianIndices, src, Rsrc::CartesianIndices) -> dest

srcのブロックを、Rsrcの範囲から、destのブロックへ、Rdestの範囲内でコピーします。2つの領域のサイズは一致している必要があります。

Examples

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
source
copyto!(dest::AbstractArray, src) -> dest

コレクション src のすべての要素を配列 dest にコピーします。配列の長さは、src の長さ n 以上でなければなりません。dest の先頭 n 個の要素は上書きされ、それ以外の要素は変更されません。

関連項目: copy!、copy。

Warning

変更される引数がほかの引数とメモリを共有している場合、予期しない動作になることがあります。

Examples

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
source
copyto!(dest, doffs, src, soffs, n)

コレクション src の線形インデックス soffs から n 個の要素をコピーし、配列 dest のインデックス doffs から格納します。dest を返します。

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

文字パラメーター tM に応じて、行列 M の要素を B に効率よくコピーします。

tMコピー先コピー元
'N'B[ir_dest, jr_dest]M[ir_src, jr_src]
'T'B[ir_dest, jr_dest]transpose(M)[ir_src, jr_src]
'C'B[ir_dest, jr_dest]adjoint(M)[ir_src, jr_src]

B[ir_dest, jr_dest] の要素は上書きされます。また、インデックス範囲のパラメーターは length(ir_dest) == length(ir_src) および length(jr_dest) == length(jr_src) を満たす必要があります。

copy_transpose! および copy_adjoint! も参照してください。

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

UniformScalingを行列にコピーします。

Julia 1.1

Julia 1.0では、このメソッドは正方形のコピー先行列のみをサポートしていました。Julia 1.1では、長方形の行列もサポートするようになりました。

source
Base.pointer — Function
pointer(array [, index])

配列または文字列のネイティブアドレスを取得します。必要に応じて位置を指定できます index。

この関数は「安全ではありません」。このポインターを使用する間は、arrayへのJulia参照が存在し続けるように注意してください。指定したコードブロック内でarray引数がガベージコレクションされないよう保護するには、GC.@preserveマクロを使用してください。

有効性が保証されるため、通常はこの関数よりRef(array[, index])を呼び出すほうが望ましいです。

source
Base.unsafe_wrap — Method
unsafe_wrap(Array, pointer::Ptr{T}, dims; own = false)

データをコピーせずに、pointerで指定されたアドレスのデータをJuliaのArrayオブジェクトでラップします。ポインターの要素型Tによって、配列の要素型が決まります。dimsには、整数(1次元配列の場合)または配列の各次元のサイズを表すタプルを指定します。ownでは、Juliaがメモリの所有権を取得するかどうかを任意で指定できます。所有権を取得した場合、配列への参照がなくなった時点で、ポインターに対してfreeが呼び出されます。

この関数が「unsafe」とされるのは、pointerが要求された長さのデータを指す有効なメモリアドレスでない場合、クラッシュするためです。unsafe_loadやunsafe_store!とは異なり、Cの厳密なエイリアシング規則と同様に、基になるデータが異なる要素型の2つの配列を通じてアクセスされないようにする責任もプログラマーにあります。

source
Base.pointer_from_objref — Function
pointer_from_objref(x)

JuliaオブジェクトのメモリアドレスをPtrとして取得します。取得したPtrが存在していても、オブジェクトがガベージコレクションされないことは保証されません。そのため、Ptrを使用する間は、オブジェクトへの参照を保持しておく必要があります。

不変オブジェクトには安定したメモリアドレスがないため、この関数を呼び出すことはできません。

unsafe_pointer_to_objrefも参照してください。

source
Base.unsafe_pointer_to_objref — Function
unsafe_pointer_to_objref(p::Ptr)

Ptr をオブジェクト参照に変換します。ポインターが有効なヒープ割り当て済み Julia オブジェクトを指していることを前提とします。そうでない場合、未定義動作が発生するため、この関数は「unsafe」とみなされ、注意して使用する必要があります。

関連項目: pointer_from_objref。

source
Base.disable_sigint — Function
disable_sigint(f::Function)

現在のタスクで関数を実行している間、Ctrl-C ハンドラーを無効にします。これは、割り込み安全でない Julia コードを呼び出す可能性のある外部コードを呼び出す場合に使用します。次のように do ブロック構文で呼び出すことを想定しています。

disable_sigint() do
    # interrupt-unsafe code
    ...
end

ワーカースレッド(Threads.threadid() != 1)では必要ありません。InterruptException はマスタースレッドにのみ送信されるためです。Julia コードや Julia ランタイムを呼び出さない外部関数は、実行中に自動的に SIGINT を無効にします。

source
Base.reenable_sigint — Function
reenable_sigint(f::Function)

関数の実行中に Ctrl-C ハンドラーを再び有効にします。disable_sigint の効果を一時的に元に戻します。

source
Base.exit_on_sigint — Function
exit_on_sigint(on::Bool)

Julia ランタイムのフラグ exit_on_sigint を設定します。false の場合、Ctrl-C(SIGINT)は try ブロック内で InterruptException として捕捉できます。これは、REPL、-e および -E を介して実行されるコード、ならびに -i オプションを指定して実行する Julia スクリプトでのデフォルトの動作です。

true の場合、Ctrl-C によって InterruptException がスローされることはありません。このようなイベント発生時にコードを実行するには、atexit が必要です。これは、-i オプションを指定せずに実行する Julia スクリプトでのデフォルトの動作です。

Julia 1.5

関数 exit_on_sigint を使用するには、Julia 1.5 以降が必要です。

source
Base.systemerror — Function
systemerror(sysfunc[, errno::Cint=Libc.errno()])
systemerror(sysfunc, iftrue::Bool)

iftrue が true の場合、説明文字列 sysfunc を指定して、errno に対する SystemError を発生させます。

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

systemerrorと同様ですが、errnoを設定する代わりに、GetLastErrorを使ってエラーコードを返すWindows API関数向けです。

source
Core.Ptr — Type
Ptr{T}

T型のデータを指すメモリアドレスです。ただし、そのメモリが実際に有効であることや、指定された型のデータを実際に表していることは保証されません。

source
Core.Ref — Type
Ref{T}

型がTのデータを安全に参照するオブジェクトです。この型は、正しい型の有効なJulia割り当てメモリを指すことが保証されています。Ref自体が参照されている限り、参照先のデータがガベージコレクターによって解放されることはありません。

Juliaでは、Refオブジェクトの参照先の値を読み書きするには、[]を使います。

型がTの値xへのRefの作成には、通常Ref(x)と記述します。また、ArrayやPtrなどのコンテナー内を指すポインターを作成する場合は、aのi番目の要素への参照を作成するために、Ref(a, i)と記述できます。

Ref{T}()は、初期化せずに型がTの値への参照を作成します。ビット型のTの場合、値は割り当てられたメモリに現在格納されているものになります。ビット型でないTの場合、参照は未定義となり、参照先の値を読み出そうとすると「UndefRefError: access to undefined reference」エラーが発生します。

Refが未定義の参照かどうかを確認するには、isassigned(ref::RefValue)を使います。たとえば、Tがビット型でない場合、isassigned(Ref{T}())はfalseです。Tがビット型の場合、isassigned(Ref{T}())は常にtrueになります。

Refオブジェクトをccall引数(Ptr型またはRef型)として渡すと、参照先データへのネイティブポインターに変換されます。ほとんどのTの場合、またはPtr{Cvoid}に変換する場合、これはオブジェクトのデータへのポインターです。Tがisbits型の場合、この値は安全に変更できます。それ以外の場合、変更は厳密に未定義の動作です。

特例として、T = Anyを設定すると、Ptr{Any}(Tが不変ならjl_value_t const* const*、そうでなければjl_value_t *const *)に変換したときに、参照そのものへのポインターが作成されます。Ptr{Cvoid}に変換した場合は、他のTと同様に、引き続きデータ領域へのポインターが返されます。

PtrのC_NULLインスタンスは、初期化するために、ccall Ref引数に渡すことができます。

Use in broadcasting

Refは、参照先の値をスカラーとして扱うために、ブロードキャストで使われることがあります。

Examples

julia> r = Ref(5) # Create a Ref with an initial value
Base.RefValue{Int64}(5)

julia> r[] # Getting a value from a Ref
5

julia> r[] = 7 # Storing a new value in a Ref
7

julia> r # The Ref now contains 7
Base.RefValue{Int64}(7)

julia> isa.(Ref([1,2,3]), [Array, Dict, Int]) # Treat reference values as scalar during broadcasting
3-element BitVector:
 1
 0
 0

julia> Ref{Function}()  # Undefined reference to a non-bitstype, Function
Base.RefValue{Function}(#undef)

julia> try
           Ref{Function}()[] # Dereferencing an undefined reference will result in an error
       catch e
           println(e)
       end
UndefRefError()

julia> Ref{Int64}()[]; # A reference to a bitstype refers to an undetermined value if not given

julia> isassigned(Ref{Int64}()) # A reference to a bitstype is always assigned
true
source
Base.isassigned — Method
isassigned(ref::RefValue)::Bool

指定されたRefに値が関連付けられているかどうかを判定します。ビット型オブジェクトのRefでは、常にtrueです。参照が未定義の場合は、falseを返します。

Examples

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
source
Base.Cstring — Type
Cstring

ネイティブ文字型Ccharで構成されるC形式の文字列です。CstringsはNUL終端です。ネイティブのワイド文字型で構成されるC形式の文字列については、Cwstringを参照してください。Cとの文字列の相互運用性について詳しくは、manualを参照してください。

source
Base.Clong — Type
Clong

ネイティブの signed long c 型と同等です。

source
Base.Culong — Type
Culong

ネイティブの unsigned long 型と同等です。

source
Base.Csize_t — Type
Csize_t

ネイティブのsize_t c型(UInt)と同等です。

source
Base.Cwstring — Type
Cwstring

ネイティブのワイド文字型Cwchar_tで構成されるCスタイル文字列です。CwstringはNUL終端です。ネイティブ文字型で構成されるCスタイル文字列については、Cstringを参照してください。Cとの文字列の相互運用性について詳しくは、manualを参照してください。

source

LLVM Interface

Core.Intrinsics.llvmcall — Function
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, ...)

第1引数で指定したLLVMコードを呼び出します。この第1引数は、いくつかの方法で指定できます。

  • 関数レベルのIRを表す文字列リテラルとして指定します(LLVMのdefineブロックに似ています)。引数は、名前のないSSA変数(%0、%1など)として連続して利用できます。
  • モジュールIRを表す文字列と、呼び出すエントリーポイント関数の名前を表す文字列を含む、2要素のタプルとして指定します。
  • 2要素のタプルとして指定しますが、モジュールはビットコードを含むVector{UInt8}として渡します。

ccallとは異なり、引数の型は型のタプルではなく、タプル型として指定する必要がある点に注意してください。型とLLVMコードはすべて、変数や式ではなくリテラルとして指定してください(これらのリテラルを生成するには、@evalが必要になる場合があります)。

使用例については、test/llvmcall.jlを参照してください。

source