2019独角兽企业重金招聘Python工程师标准>>>

1. static void loadLibrary(Class fromClass, String name,
2. boolean isAbsolute) {}

1. for (int i = 0; i < size; i++) {
2. NativeLibrary lib = (NativeLibrary)libs.elementAt(i);
3. if (name.equals(lib.name)) {
4. return true;
5. }
6. }

1. JNIEXPORT void JNICALL
2. Java_java_lang_ClassLoader_00024NativeLibrary_load
3. (JNIEnv *env, jobject this, jstring name)
4. {
5. const char *cname;
6. jint jniVersion;
7. jthrowable cause;
8. void * handle;
9. if (!initIDs(env))
10. return;
11. cname = JNU_GetStringPlatformChars(env, name, 0);
12. if (cname == 0)
13. return;
14. handle = JVM_LoadLibrary(cname);
15. if (handle) {
16. const char *onLoadSymbols[] = JNI_ONLOAD_SYMBOLS;
17. JNI_OnLoad_t JNI_OnLoad;
18. int i;
19. for (i = 0; i < sizeof(onLoadSymbols) / sizeof(char *); i++) {
20. JNI_OnLoad = (JNI_OnLoad_t)
21. JVM_FindLibraryEntry(handle, onLoadSymbols[i]);
22. if (JNI_OnLoad) {
23. break;
24. }
25. }
26. if (JNI_OnLoad) {
27. JavaVM *jvm;
28. (*env)->GetJavaVM(env, &jvm);
29. jniVersion = (*JNI_OnLoad)(jvm, NULL);
30. } else {
31. jniVersion = 0x00010001;
32. }
33. cause = (*env)->ExceptionOccurred(env);
34. if (cause) {
35. (*env)->ExceptionClear(env);
36. (*env)->Throw(env, cause);
37. JVM_UnloadLibrary(handle);
38. goto done;
39. }
40. if (!JVM_IsSupportedJNIVersion(jniVersion)) {
41. char msg[256];
42. jio_snprintf(msg, sizeof(msg),
43. "unsupported JNI version 0x%08X required by %s",
44. jniVersion, cname);
45. JNU_ThrowByName(env, "java/lang/UnsatisfiedLinkError", msg);
46. JVM_UnloadLibrary(handle);
47. goto done;
48. }
49. (*env)->SetIntField(env, this, jniVersionID, jniVersion);
50. } else {
51. cause = (*env)->ExceptionOccurred(env);
52. if (cause) {
53. (*env)->ExceptionClear(env);
54. (*env)->SetLongField(env, this, handleID, (jlong)NULL);
55. (*env)->Throw(env, cause);
56. }
57. goto done;
58. }
59. (*env)->SetLongField(env, this, handleID, ptr_to_jlong(handle));
60. done:
61. JNU_ReleaseStringPlatformChars(env, name, cname);
62. }

1. void * os::dll_load(const char *filename, char *ebuf, int ebuflen)

1. void* os::dll_lookup(void* handle, const char* name) {
2. pthread_mutex_lock(&dl_mutex);
3. void* res = dlsym(handle, name);
4. pthread_mutex_unlock(&dl_mutex);
5. return res;
6. }

1. JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void* reserved)
2. {}

1. jboolean Threads::is_supported_jni_version(jint version) {
2. if (version == JNI_VERSION_1_2) return JNI_TRUE;
3. if (version == JNI_VERSION_1_4) return JNI_TRUE;
4. if (version == JNI_VERSION_1_6) return JNI_TRUE;
5. return JNI_FALSE;
6. }

1. JNIEXPORT jint JNICALL Java_test_symlink
2. (JNIEnv *, jobject, jstring, jstring);

1. static JNINativeMethod methods[] = {
2. {"retrieveDirectives",  "()Ljava/lang/AssertionStatusDirectives;", (void *)&JVM_AssertionStatusDirectives}
3. };
4. (*env)->RegisterNatives(env, cls, methods,
5. sizeof(methods)/sizeof(JNINativeMethod));

1. address* native_function_addr() const          { assert(is_native(), "must be native"); return (address*) (this+1);

1. void methodOopDesc::link_method(methodHandle h_method, TRAPS) {
2. assert(_i2i_entry == NULL, "should only be called once");
3. assert(_adapter == NULL, "init'd to NULL" );
4. assert( _code == NULL, "nothing compiled yet" );
5. // Setup interpreter entrypoint
6. assert(this == h_method(), "wrong h_method()" );
7. address entry = Interpreter::entry_for_method(h_method); //找到对应的方法 entry
8. assert(entry != NULL, "interpreter entry must be non-null");
9. // Sets both _i2i_entry and _from_interpreted_entry
10. set_interpreter_entry(entry); //并且把entry设置到了methodoop中
11. ...
12. }

1. static address    entry_for_method(methodHandle m)            { return _entry_table[method_kind(m)]; }

1. #define method_entry(kind)                                                                    \
2. { CodeletMark cm(_masm, "method entry point (kind = " #kind ")");                    \
3. Interpreter::_entry_table[Interpreter::kind] = generate_method_entry(Interpreter::kind);  \
4. }
5. // all non-native method kinds
6. method_entry(zerolocals)
7. method_entry(zerolocals_synchronized)
8. method_entry(empty)
9. method_entry(accessor)
10. method_entry(abstract)
11. method_entry(method_handle)
12. method_entry(java_lang_math_sin  )
13. method_entry(java_lang_math_cos  )
14. method_entry(java_lang_math_tan  )
15. method_entry(java_lang_math_abs  )
16. method_entry(java_lang_math_sqrt )
17. method_entry(java_lang_math_log  )
18. method_entry(java_lang_math_log10)
19. // all native method kinds (must be one contiguous block)
20. Interpreter::_native_entry_begin = Interpreter::code()->code_end();
21. method_entry(native)
22. method_entry(native_synchronized)
23. Interpreter::_native_entry_end = Interpreter::code()->code_end();
24. #undef method_entry

1. address AbstractInterpreterGenerator::generate_method_entry(
2. AbstractInterpreter::MethodKind kind) {
3. // determine code generation flags
4. bool synchronized = false;
5. address entry_point = NULL;
6. switch (kind) {
7. case Interpreter::zerolocals             :                                                                             break;
8. case Interpreter::zerolocals_synchronized: synchronized = true;                                                        break;
9. case Interpreter::native                 : entry_point = ((InterpreterGenerator*) this)->generate_native_entry(false); break;
10. case Interpreter::native_synchronized    : entry_point = ((InterpreterGenerator*) this)->generate_native_entry(true);  break;
11. case Interpreter::empty                  : entry_point = ((InterpreterGenerator*) this)->generate_empty_entry();       break;
12. case Interpreter::accessor               : entry_point = ((InterpreterGenerator*) this)->generate_accessor_entry();    break;
13. case Interpreter::abstract               : entry_point = ((InterpreterGenerator*) this)->generate_abstract_entry();    break;
14. case Interpreter::method_handle          : entry_point = ((InterpreterGenerator*) this)->generate_method_handle_entry();break;
15. case Interpreter::java_lang_math_sin     : // fall thru
16. case Interpreter::java_lang_math_cos     : // fall thru
17. case Interpreter::java_lang_math_tan     : // fall thru
18. case Interpreter::java_lang_math_abs     : // fall thru
19. case Interpreter::java_lang_math_log     : // fall thru
20. case Interpreter::java_lang_math_log10   : // fall thru
21. case Interpreter::java_lang_math_sqrt    : entry_point = ((InterpreterGenerator*) this)->generate_math_entry(kind);    break;
22. default                                  : ShouldNotReachHere();                                                       break;
23. }
24. if (entry_point) {
25. return entry_point;
26. }
27. return ((InterpreterGenerator*) this)->
28. generate_normal_entry(synchronized);
29. }

在方法methodOopDesc::link_method 中，设置了_i2i_entry,和_from_interpreted_entry为entry 也是就在native的情况下设置了generate_native_entry

1. void set_interpreter_entry(address entry)      { _i2i_entry = entry;  _from_interpreted_entry = entry; }

1. void TemplateTable::invokespecial(int byte_no) {
2. transition(vtos, vtos);
3. assert(byte_no == f1_byte, "use this argument");
4. prepare_invoke(rbx, noreg, byte_no);
5. // do the call
6. __ verify_oop(rbx);
7. __ profile_call(rax);
8. __ jump_from_interpreted(rbx, rax);
9. }

1. case Bytecodes::_invokevirtual:
2. case Bytecodes::_invokespecial:
3. case Bytecodes::_invokestatic:
4. case Bytecodes::_invokeinterface:
5. entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_invoke);
6. break;

而函数

interpreterRuntime:resolve_invoke

-->LinkResolver::resolve_invoke

-->LinkResolver::resolve_special_call

-->LinkResolver::linktime_resolve_special_method

-->LinkResolver::resolve_method

不论什么调用方式，最后都会调用LinkResolver::resolve_method 找到真实的调用方法，通过runtime_resolve_special_method把method指针作为methodhandle存放到CallInfo 中传回InterperterRuntime::resolve_invoke中，同时在CallInfo::set_common当设置-Xcomp情况下，决定是否需要编译方法。

我们可以看到方法prepare_invoke，已经找到了methodoop指针并且存放到寄存器rbx中

我们看到跳转到了methodoop中的_from_interpreted_entry，也就是在前面的博客里（java JNI (四) 初始化JNI方法）说的generate_native_entry 中

在这篇博客并没有太多的涉及到native方法的调用，而是asm解释器在解释一个方法的时候如何link到所对应method，并且找到处理method的entry。

在前面的博客中已经提到过JNI的entry是generate_native_entry，也就是说方法generate_native_entry才是最终调用的我们自己写的库文件里的方法

针对不同的解释器的类型，会调用不同的generate_native_entry，下面主要讨论的还是以template interpreter为主

如果是X86的，可以参考templateInterpreter_x86_64.cpp

具体我们来看prepare_native_call方法的实现

在代码中

if (!m->has_native_function()) {
    NativeLookup::lookup(m, in_base_library, CHECK);
  }

首先先检查一下是不是已经在method里面定义了native的方法，也就是我们前面提到的JNI中的（RegisterNatives方法）中是不是已经单独RegisterNatives注册了native方法

如果没有的话，将按照javah生成的JNI头文件里的方法的名字来绑定，也就是lookup里做的事情，然后设置回method的native的方法中去，保证调用只初始化一次，不是每次调用都去查找一遍

这样在方法prepare_native_call 中，我们可以和前面的博客（java JNI 实现原理 (三) JNI中的RegisterNatives方法）,完整的联系起来。

下面大概的介绍一下，完整的native call的过程

a.  初始化一些参数，把方法的一些信息放到对应的寄存器上

b.  检查是否需要锁，如果需要，锁到对应的object

c.  设置几个handler, signature hanlder, result handler, mirror handler(static 方法)

d.  找到 native 方法的指针，设置到rax寄存器中

e.  传入JNIEnv 对象在native方法第一个参数（因为JNIEnv 对象在Java 代码中的native 方法没有，而在自己定义的native方法里用来取得jni的运行环境的，所以需要在这里额外传入）

f.  设置java栈信息 last_java_frame

g.  设置线程信息为_thread_in_native

h.  运行native 方法

i.   在多核的情况下，使用Membar清楚内存cache

j.   检查是否在safepoint的点

k. 还原java 栈信息 reset_last_java_frame

l.  对结果进行一些处理

m. 处理过程中的异常

n.  释放锁

o.  调用result hanlder 的到结果