1

One of the ways to register native functions in JNI is by using the function RegisterNatives(). An example (although seemingly with some errors) can be found in the Android documentation here. Here's a code example demonstrating this technique:

#include <jni.h>

void JNICALL test(JNIEnv* const environment, jobject const objectOrClass) {
}

extern "C" JNIEXPORT jint JNI_OnLoad(JavaVM* const vm, void* const reserved) {
    JNIEnv* environment;

    vm->GetEnv(reinterpret_cast<void**>(&environment), JNI_VERSION_1_6);

    auto const classRef = environment->FindClass("com/example/test/MainActivity");

    JNINativeMethod method;

    method.name = "test";
    method.signature = "()V";
    method.fnPtr = reinterpret_cast<void*>(test);

    environment->RegisterNatives(classRef, &method, 1);

    return JNI_VERSION_1_6;
}

Using RegisterNatives() requires casting (non-member) function pointers to type void*, as shown above. According to this documentation, this isn't necessarily portable in C++. It may be guaranteed to work in some environments (such as POSIX), but the behavior is otherwise implementation-dependent.

I wouldn't expect this functionality to be exposed this way if it wasn't reliable, but does either JNI or Android offer any guarantees that this can be counted on to work? Is it just assumed that JNI and/or Android will always be running in environments where casting between function pointers and void* is supported?

EDIT:

After further consideration, it seems JNI would almost have to do something non-portable with respect to native functions, irrespective of the cast issue. The only information about the function JNI has (other than the address) is a string describing the argument and return types, so it seems unlikely that the void* will ever be cast back to a valid function pointer and used in the conventional way. Presumably the calls are instead made via low-level platform-specific code.

It still seems like a requirement that function-pointer-to-void* casts be well-behaved, so if anyone knows if or how JNI guarantees that, I'd still be interested to know.

scg
  • 449
  • 1
  • 3
  • 11
  • 1
    Since you are using a specific implementation (Android) I would say you could be excused for relying on platform specific behaviour (unless you would like the code to work elsewhere of course). – Jesper Juhl Feb 04 '20 at 19:13
  • 2
    This question is informative: https://stackoverflow.com/questions/57355248/casting-an-address-of-subroutine-into-void-pointer – Andrew Henle Feb 04 '20 at 23:28
  • @Andrew Henle: Thanks for the link. That reinforces my understanding that the cast isn't portable, but I'm still curious as to if/how that affects JNI. In any case, I updated my post with some additional comments. – scg Feb 06 '20 at 02:16

0 Answers0