rust-bindgen | Automatically generates Rust FFI bindings to C | Wrapper library

Short answer: just cast it to *mut T and pass it to C.

Long answer:

It's best to first understand why casting *const T to *mut T is prone to undefined behaviour.

Rust's memory model ensures that a &mut T will not alias with anything else, so the compiler is free to, say, clobber T entirely and then restore its content, and the programmer could not observe that behaviour. If a &mut T and &T co-exists and point to the same location, undefined behaviour arises because what will happen if you read from &T while compiler clobbers &mut T? Similarly, if you have &T, the compiler assumes no one will modify it (excluding interior mutability through UnsafeCell), and undefined behaviour arise if the memory it points to is modified.

With the background, it's easy to see why *const T to *mut T is dangerous -- you cannot dereference the resulting pointer. If you ever dereference the *mut T, you've obtained a &mut T, and it'll be UB. However, the casting operation itself is safe, and you can safely cast the *mut T back to *const T and dereference it.

This is Rust semantics; on the C-side, the guarantee about T* is very weak. If you hold a T*, the compiler cannot assume there are no sharers. In fact, the compiler cannot even assert that it points to valid address (it could be null or past-the-end pointer). C compiler cannot generate store instructions to the memory location unless the code write to the pointer explicitly.

The weaker meaning of T* in C-side means that it won't violate Rust's assumption about semantics of &T. You can safely cast &T to *mut T and pass it to C, provided that C-side never modifies the memory pointed by the pointer.

Note that you can instruct the C compiler that the pointer won't alias with anything else with T * restrict, but as the C code you mentioned is not strict with const-correctness, it probably does not use restrict as well.

Use <*const T>::as_ref¹:

You are going to need to compile the code, at least to IR. This is because the triviality of a C++ class can depend on an arbitrarily complicated computation whose inputs may include platform attributes, available headers, preprocessor defines, compiler options etc., which can thus only be carried out by a C++ compiler.

If you are invoking clang as a binary the option to emit IR is clang -S -emit-llvm and you will then want to parse the LLVM IR output; for example for

Found the answer shortly after posting the question here.

The problem lies with the .clang_arg() call. There must be only one include per call to that function but multiple calls to the function are allowed.

The working build.rs would then include the following calls:

Before I dig in, I'll point out that I'm a relative beginner with Rust and I'm not particularly familiar with what bindgen produces, but I know OpenCL quite well. So please bear with me if my Rust syntax is off.

The most obvious thing that sticks out for me is that passing the buffer to clSetKernelArg using buffer as *const c_void looks suspicious. My understanding is that your code is roughly equivalent to this C: