¿El enlace OCaml de LLVM incluye soporte intrínseco?

Question

Parece que no puedo encontrar una referencia a los intrínsecos en el enlace oficial OCaml de LLVM, más allá de la función is_intrinsic.

Estoy construyendo un backend que necesita realizar alguna generación de código específica de destino (para SSE, AVX y NEON), y los intrínsecos son la ruta estándar en la API de C++.

Answer 1

El OCaml soportes intrínsecos de unión exactamente de la misma manera que el lenguaje C de unión:

No hay soporte especial para ellos en la interfaz (como la hay en toda la interfaz C++), pero puede ser declarada Extern y llamado como cualquier otra función.

ej .:

open Llvm 

let() = 
    let c = create_context() in 

    let f32_t = float_type c in 
    let f32x4_t = vector_type f32_t 4 in 

    let m = create_module c "test" in 

    (* declare void @printv(<4 x float>) 
    * nonce extern which forces preservation of vector results *) 
    let printv = 
    declare_function "printv" 
    (function_type (void_type c) [|f32x4_t|]) m in 

    (* declare <4 x float> @llvm.x86.sse.sqrt.ps(<4 x float>) nounwind readnone *) 
    let sqrtps = 
    declare_function "llvm.x86.sse.sqrt.ps" 
    (function_type f32x4_t [|f32x4_t|]) m in 

    (* define i32 @main() { entry: *) 
    let main = define_function "main" (function_type i32_t [| |]) m in 
    let at_entry = builder_at_end c (entry_block main) in 

    (*%sqrtps = call <4 x float> @llvm.x86.sse.sqrt.ps(<4 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00>)*) 
    let cv1234 = const_vector [| const_float f32_t 1.0; const_float f32_t 2.0; 
    const_float f32_t 3.0; const_float f32_t 4.0 |] in 
    let sqrt = build_call sqrtps [| cv1234 |] "sqrtps" at_entry in 

    (* call void printv(sqrtps) *) 
    ignore (build_call printv [| sqrt |] "" at_entry); 

    (* ret void *) 
    ignore (build_ret (const_null i32_t) at_entry); 

    (* Print .ll to stderr *) 
    dump_module m 

produce:

; ModuleID = 'test' 

declare void @printv(<4 x float>) 

declare <4 x float> @llvm.x86.sse.sqrt.ps(<4 x float>) nounwind readnone 

define i32 @main() { 
entry: 
    %sqrtps = call <4 x float> @llvm.x86.sse.sqrt.ps(<4 x float> <float 1.000000e+00, float 2.000000e+00, float 3.000000e+00, float 4.000000e+00>) 
    call void @printv(<4 x float> %sqrtps) 
    ret i32 0 
} 

que compila en x86 invocar correctamente sqrtps en los xmm registros.

Answer 2

Descargo de responsabilidad: Nunca he usado LLVM. Después de echar un vistazo rápido a la documentación vinculante, parece que la respuesta es "no". Sin embargo, existe un soporte para el ensamblaje en línea, que puede o no satisfacer sus necesidades.

Finalmente, parece que los desarrolladores de LLVM aceptan que el enlace OCaml no está completo: si lo desea, puede agregar algunas funciones adicionales (si no está familiarizado con OCaml, las vinculaciones C realmente no son la parte más fácil, pero los enlaces LLVM están llenos de código de ejemplo que probablemente pueda adaptar con éxito a otras funciones LLVM), luego proporcione un parche para ello en la lista LLVMdev.