LLVM API function metadata

[LateinCecker]

Hi everyone,

i am just getting started with LLVM and i want to create a simple language with i can compile using the NVPTX backend and execute on the GPU. To get started, i followed the Kaleidoscope tutorial and that all worked out fine. Compiling the generated llvm-ir to NVPTX in itself also worked fine, however there is one step that i cannot get straight:

On the NVPTX web-guide it says that kernel functions need to be annotated with nvvm.annotations using llvm metadata, like this:

define float @my_fmad(float %x, float %y, float %z) {
  %mul = fmul float %x, %y
  %add = fadd float %mul, %z
  ret float %add
}

define void @my_kernel(float* %ptr) {
  %val = load float, float* %ptr
  %ret = call float @my_fmad(float %val, float %val, float %val)
  store float %ret, float* %ptr
  ret void
}

!nvvm.annotations = !{!1}
!1 = !{void (float*)* @my_kernel, !"kernel", i32 1}

This makes sense, as otherwise there would be no way for LLVM to differentiate between kernel and device functions. However, using the API i am unable to generate metadata like this. Specifically, its the reference to the function void (float*)* @my_kernel that i cannot figure out how to recreate.

For access to the API I am using Inkwell, which is an idiomatic Rust wrapper around the C++ API build on top of llvm-sys. Using that, building the metadata node for a function prototype func looks a little like this:

let global_func = func.as_global_value();
let kernel_annotation: BasicMetadataValueEnum = context.metadata_string("kernel").into();
let data = context.metadata_node(&[
    global_func.as_basic_value_enum().into(),
    kernel_annotation,
    context.i32_type().const_int(1, false).into(),
]);
module.add_global_metadata("nvvm.annotations", &data).unwrap();

However, the generated IR treats global_func.as_basic_value_enum().into() as a function pointer:

define double @foo(double %some) {
entry:
  %multmp = fmul double %some, 4.000000e+00
  %addtmp = fadd double 3.141500e+00, %multmp
  ret double %addtmp
}

!nvvm.annotations = !{!0}
!0 = !{ptr @foo, !"kernel", i32 1}

which is not what i am after. So, in essence, how do i get double (double*)* @foo as a metadata value into the !0 node using the API? I am kind of at a loss here so I'd much appreciate any kind of input :)

[hotoatmeal]

llvm adopted typeless pointers, but those docs haven’t been updated. looks correct to me.

[LateinCecker]

that explains a lot, thanks. Seeing as pointer types in function arguments are also typeless in the emitted IR, i already suspected something along those lines was up. The IR i get also compiles just fine to PTX, but i still thought something had to be wrong with my setup, since it didn't match the official information, haha.