标签：enc alternate pat turn 源码解读 编译 字节码 || dcl
写一个java文件
public static void main(String[] args) { String str1="abc"; String str2 ="abc"; String str3=new String("abc"); boolean b1= str1==str2; boolean b2= str1==str3; }
查看字节码code
0 ldc #4 <abc> 2 astore_1 3 ldc #4 <abc> 5 astore_2 6 new #5 <java/lang/String> 9 dup 10 ldc #4 <abc> 12 invokespecial #6 <java/lang/String.<init>> 15 astore_3 16 aload_1 17 aload_2 18 if_acmpne 25 (+7) 21 iconst_1 22 goto 26 (+4) 25 iconst_0 26 istore 4 28 aload_1 29 aload_3 30 if_acmpne 37 (+7) 33 iconst_1 34 goto 38 (+4) 37 iconst_0 38 istore 5 40 getstatic #7 <java/lang/System.out> 43 ldc #8 <helloworld!>
能看待这个一个是ldc #4,其中#4的类型是
JVM_CONSTANT_String
然后对于String类的解析,会比较明白,先加载java/lang/String类,在生成oop对象,而ldc #4查看字节码的解析如下:
void TemplateTable::ldc(bool wide) { transition(vtos, vtos); Label call_ldc, notFloat, notClass, Done; if (wide) { __ get_unsigned_2_byte_index_at_bcp(rbx, 1); } else { __ load_unsigned_byte(rbx, at_bcp(1)); } __ get_cpool_and_tags(rcx, rax); const int base_offset = ConstantPool::header_size() * wordSize; const int tags_offset = Array<u1>::base_offset_in_bytes(); // get type __ xorptr(rdx, rdx); __ movb(rdx, Address(rax, rbx, Address::times_1, tags_offset)); // unresolved class - get the resolved class __ cmpl(rdx, JVM_CONSTANT_UnresolvedClass); __ jccb(Assembler::equal, call_ldc); // unresolved class in error (resolution failed) - call into runtime // so that the same error from first resolution attempt is thrown. __ cmpl(rdx, JVM_CONSTANT_UnresolvedClassInError); __ jccb(Assembler::equal, call_ldc); // resolved class - need to call vm to get java mirror of the class __ cmpl(rdx, JVM_CONSTANT_Class); __ jcc(Assembler::notEqual, notClass); __ bind(call_ldc); __ movl(rcx, wide); call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), rcx); __ push(atos); __ jmp(Done); __ bind(notClass); __ cmpl(rdx, JVM_CONSTANT_Float); __ jccb(Assembler::notEqual, notFloat); // ftos __ fld_s( Address(rcx, rbx, Address::times_ptr, base_offset)); __ push(ftos); __ jmp(Done); __ bind(notFloat); #ifdef ASSERT { Label L; __ cmpl(rdx, JVM_CONSTANT_Integer); __ jcc(Assembler::equal, L); // String and Object are rewritten to fast_aldc __ stop("unexpected tag type in ldc"); __ bind(L); } #endif // itos JVM_CONSTANT_Integer only __ movl(rax, Address(rcx, rbx, Address::times_ptr, base_offset)); __ push(itos); __ bind(Done); }
就算加上了汇编完成的东西
---------------------------------------------------------------------- ldc 18 ldc [0x00000000033c7840, 0x00000000033c79a0] 352 bytes 0x00000000033c7840: push %rax 0x00000000033c7841: jmpq 0x00000000033c7870 0x00000000033c7846: sub $0x8,%rsp 0x00000000033c784a: vmovss %xmm0,(%rsp) 0x00000000033c784f: jmpq 0x00000000033c7870 0x00000000033c7854: sub $0x10,%rsp 0x00000000033c7858: vmovsd %xmm0,(%rsp) 0x00000000033c785d: jmpq 0x00000000033c7870 0x00000000033c7862: sub $0x10,%rsp 0x00000000033c7866: mov %rax,(%rsp) 0x00000000033c786a: jmpq 0x00000000033c7870 0x00000000033c786f: push %rax 0x00000000033c7870: movzbl 0x1(%r13),%ebx 0x00000000033c7875: mov -0x18(%rbp),%rcx 0x00000000033c7879: mov 0x8(%rcx),%rcx 0x00000000033c787d: mov 0x8(%rcx),%rcx 0x00000000033c7881: mov 0x8(%rcx),%rax 0x00000000033c7885: movzbl 0x4(%rax,%rbx,1),%edx // unresolved class - get the resolved class __ cmpl(rdx, JVM_CONSTANT_UnresolvedClass); __ jccb(Assembler::equal, call_ldc); 0x00000000033c788a: cmp $0x64,%edx 0x00000000033c788d: je 0x00000000033c789d // unresolved class in error state - call into runtime to throw the error // from the first resolution attempt __ cmpl(rdx, JVM_CONSTANT_UnresolvedClassInError); __ jccb(Assembler::equal, call_ldc); 0x00000000033c788f: cmp $0x67,%edx 0x00000000033c7892: je 0x00000000033c789d // resolved class - need to call vm to get java mirror of the class __ cmpl(rdx, JVM_CONSTANT_Class); __ jcc(Assembler::notEqual, notClass); 0x00000000033c7894: cmp $0x7,%edx 0x00000000033c7897: jne 0x00000000033c794d __ movl(c_rarg1, wide); wide=false 0x00000000033c789d: mov $0x0,%edx 0x00000000033c78a2: callq 0x00000000033c78ac 0x00000000033c78a7: jmpq 0x00000000033c7947 0x00000000033c78ac: lea 0x8(%rsp),%rax 0x00000000033c78b1: mov %r13,-0x38(%rbp) 0x00000000033c78b5: mov %r15,%rcx 0x00000000033c78b8: mov %rbp,0x1e8(%r15) 0x00000000033c78bf: mov %rax,0x1d8(%r15) 0x00000000033c78c6: sub $0x20,%rsp 0x00000000033c78ca: test $0xf,%esp 0x00000000033c78d0: je 0x00000000033c78e8 0x00000000033c78d6: sub $0x8,%rsp 0x00000000033c78da: callq 0x000000006aad9cd0 0x00000000033c78df: add $0x8,%rsp 0x00000000033c78e3: jmpq 0x00000000033c78ed 0x00000000033c78e8: callq 0x000000006aad9cd0 0x00000000033c78ed: add $0x20,%rsp 0x00000000033c78f1: movabs $0x0,%r10 0x00000000033c78fb: mov %r10,0x1d8(%r15) 0x00000000033c7902: movabs $0x0,%r10 0x00000000033c790c: mov %r10,0x1e8(%r15) 0x00000000033c7913: cmpq $0x0,0x8(%r15) 0x00000000033c791b: je 0x00000000033c7926 0x00000000033c7921: jmpq 0x00000000033b07e0 0x00000000033c7926: mov 0x238(%r15),%rax 0x00000000033c792d: movabs $0x0,%r10 0x00000000033c7937: mov %r10,0x238(%r15) 0x00000000033c793e: mov -0x38(%rbp),%r13 0x00000000033c7942: mov -0x30(%rbp),%r14 0x00000000033c7946: retq 0x00000000033c7947: push %rax 0x00000000033c7948: jmpq 0x00000000033c796b __ bind(notClass); __ cmpl(rdx, JVM_CONSTANT_Float); 常量值为4 __ jccb(Assembler::notEqual, notFloat); 0x00000000033c794d: cmp $0x4,%edx 0x00000000033c7950: jne 0x00000000033c7966 0x00000000033c7952: vmovss 0x50(%rcx,%rbx,8),%xmm0 0x00000000033c7958: sub $0x8,%rsp 0x00000000033c795c: vmovss %xmm0,(%rsp) 0x00000000033c7961: jmpq 0x00000000033c796b __ bind(notFloat); 0x00000000033c7966: mov 0x50(%rcx,%rbx,8),%eax 0x00000000033c796a: push %rax //下一条指令取指 0x00000000033c796b: movzbl 0x2(%r13),%ebx 0x00000000033c7970: add $0x2,%r13 0x00000000033c7974: movabs $0x6b2143f0,%r10 0x00000000033c797e: jmpq *(%r10,%rbx,8) 0x00000000033c7982: nopw 0x0(%rax,%rax,1) 0x00000000033c7988: add %al,(%rax) 0x00000000033c798a: add %al,(%rax) 0x00000000033c798c: add %al,(%rax) 0x00000000033c798e: add %al,(%rax) 0x00000000033c7990: add %al,(%rax) 0x00000000033c7992: add %al,(%rax) 0x00000000033c7994: add %al,(%rax) 0x00000000033c7996: add %al,(%rax) 0x00000000033c7998: add %al,(%rax) 0x00000000033c799a: add %al,(%rax) 0x00000000033c799c: add %al,(%rax) 0x00000000033c799e: add %al,(%rax) ----------------------------------------------------------------------
也分析不出来,打断点始终打不到,对于ldc 加载类,却可以打到断点,真是迷惑,查了一圈看了一篇文章说会调用StringTable::intern
文章链接:iizhihu.com/question/60778124
但是也没说明白调用链,开头就直接说了
给出以下逻辑
查看源码也是在bytecodeInterpreter.cpp找到了这段内容
CASE(_ldc_w): CASE(_ldc): { u2 index; bool wide = false; int incr = 2; // frequent case if (opcode == Bytecodes::_ldc) { index = pc[1]; } else { index = Bytes::get_Java_u2(pc+1); incr = 3; wide = true; } ConstantPool* constants = METHOD->constants(); switch (constants->tag_at(index).value()) { case JVM_CONSTANT_Integer: SET_STACK_INT(constants->int_at(index), 0); break; case JVM_CONSTANT_Float: SET_STACK_FLOAT(constants->float_at(index), 0); break; case JVM_CONSTANT_String: { oop result = constants->resolved_references()->obj_at(index); if (result == NULL) { CALL_VM(InterpreterRuntime::resolve_ldc(THREAD, (Bytecodes::Code) opcode), handle_exception); SET_STACK_OBJECT(THREAD->vm_result(), 0); THREAD->set_vm_result(NULL); } else { VERIFY_OOP(result); SET_STACK_OBJECT(result, 0); } break; } case JVM_CONSTANT_Class: VERIFY_OOP(constants->resolved_klass_at(index)->java_mirror()); SET_STACK_OBJECT(constants->resolved_klass_at(index)->java_mirror(), 0); break; case JVM_CONSTANT_UnresolvedClass: case JVM_CONSTANT_UnresolvedClassInError: CALL_VM(InterpreterRuntime::ldc(THREAD, wide), handle_exception); SET_STACK_OBJECT(THREAD->vm_result(), 0); THREAD->set_vm_result(NULL); break; default: ShouldNotReachHere(); } UPDATE_PC_AND_TOS_AND_CONTINUE(incr, 1); }
这个在里面打不了断点呢,上便的逻辑一点都不清楚,如何是好? 这个cpp文件都是灰色的,最后有这个 #ifndef CC_INTERP ,感觉不是模板编译器,
那么,参考知乎的文章,打了断点 发现bytecode 是fast_aldc,并且要加载的字符串是"system",与ldc 指令对上了呢,没想明白怎么出来的一个_fast_ldc指令,对于指令的解析,已经看过了没有对应的Constant String ,tag保存的类型为08的,最后还是让我发现了,hotspot在方法链接的时候将ldc 重写成了_fast_aldc,自己没看方法重写的代码,不知道呢
为什么呢?其实这不怪你,因为这是在连接的时候重写了,自己没看这部分内容,看来还要补起来 // Rewrites a method given the index_map information void Rewriter::scan_method(Method* method, bool reverse, bool* invokespecial_error) { .. case Bytecodes::_ldc: case Bytecodes::_fast_aldc: // if reverse=true maybe_rewrite_ldc(bcp, prefix_length+1, false, reverse); .. } // Rewrite some ldc bytecodes to _fast_aldc void Rewriter::maybe_rewrite_ldc(address bcp, int offset, bool is_wide, bool reverse) { if (!reverse) { assert((*bcp) == (is_wide ? Bytecodes::_ldc_w : Bytecodes::_ldc), "not ldc bytecode"); address p = bcp + offset; int cp_index = is_wide ? Bytes::get_Java_u2(p) : (u1)(*p); constantTag tag = _pool->tag_at(cp_index).value(); /** * bool is_method_handle() const { return _tag == JVM_CONSTANT_MethodHandle; } * bool is_method_type() const { return _tag == JVM_CONSTANT_MethodType; } * bool is_string() const { return _tag == JVM_CONSTANT_String; } */ if (tag.is_method_handle() || tag.is_method_type() || tag.is_string()) { int ref_index = cp_entry_to_resolved_references(cp_index); if (is_wide) { (*bcp) = Bytecodes::_fast_aldc_w; assert(ref_index == (u2)ref_index, "index overflow"); Bytes::put_native_u2(p, ref_index); } else { (*bcp) = Bytecodes::_fast_aldc;//将ldc转化成_fast_aldc,这个你不看到这里,怎么也跟踪不到呢?? assert(ref_index == (u1)ref_index, "index overflow"); (*p) = (u1)ref_index; } } } else { Bytecodes::Code rewritten_bc = (is_wide ? Bytecodes::_fast_aldc_w : Bytecodes::_fast_aldc); if ((*bcp) == rewritten_bc) { address p = bcp + offset; int ref_index = is_wide ? Bytes::get_native_u2(p) : (u1)(*p); int pool_index = resolved_references_entry_to_pool_index(ref_index); if (is_wide) { (*bcp) = Bytecodes::_ldc_w; assert(pool_index == (u2)pool_index, "index overflow"); Bytes::put_Java_u2(p, pool_index); } else { (*bcp) = Bytecodes::_ldc; assert(pool_index == (u1)pool_index, "index overflow"); (*p) = (u1)pool_index; } } } }
接着就是
那看ldc和fast_aldc的汇编器,这里面写着生成oop对象
// Fast path for caching oop constants. void TemplateTable::fast_aldc(bool wide) { transition(vtos, atos); Register result = rax; Register tmp = rdx; int index_size = wide ? sizeof(u2) : sizeof(u1); Label resolved; // We are resolved if the resolved reference cache entry contains a // non-null object (String, MethodType, etc.) assert_different_registers(result, tmp); __ get_cache_index_at_bcp(tmp, 1, index_size); __ load_resolved_reference_at_index(result, tmp); __ testl(result, result); __ jcc(Assembler::notZero, resolved); address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_ldc); // first time invocation - must resolve first __ movl(tmp, (int)bytecode()); __ call_VM(result, entry, tmp); __ bind(resolved); if (VerifyOops) { __ verify_oop(result); } }
如下
oop Bytecode_loadconstant::resolve_constant(TRAPS) const { assert(_method.not_null(), "must supply method to resolve constant"); int index = raw_index(); ConstantPool* constants = _method->constants(); if (has_cache_index()) { return constants->resolve_cached_constant_at(index, THREAD); } else { return constants->resolve_constant_at(index, THREAD); } } --------------- oop resolve_cached_constant_at(int cache_index, TRAPS) { constantPoolHandle h_this(THREAD, this); return resolve_constant_at_impl(h_this, _no_index_sentinel, cache_index, THREAD); } --------------- // Called to resolve constants in the constant pool and return an oop. // Some constant pool entries cache their resolved oop. This is also // called to create oops from constants to use in arguments for invokedynamic oop ConstantPool::resolve_constant_at_impl(constantPoolHandle this_oop, int index, int cache_index, TRAPS) { oop result_oop = NULL; Handle throw_exception; if (cache_index == _possible_index_sentinel) { // It is possible that this constant is one which is cached in the objects. // We‘ll do a linear search. This should be OK because this usage is rare. assert(index > 0, "valid index"); cache_index = this_oop->cp_to_object_index(index); } assert(cache_index == _no_index_sentinel || cache_index >= 0, ""); assert(index == _no_index_sentinel || index >= 0, ""); if (cache_index >= 0) { result_oop = this_oop->resolved_references()->obj_at(cache_index); if (result_oop != NULL) { return result_oop; // That was easy... } index = this_oop->object_to_cp_index(cache_index); } jvalue prim_value; // temp used only in a few cases below int tag_value = this_oop->tag_at(index).value(); switch (tag_value) { case JVM_CONSTANT_UnresolvedClass: case JVM_CONSTANT_UnresolvedClassInError: case JVM_CONSTANT_Class: { assert(cache_index == _no_index_sentinel, "should not have been set"); Klass* resolved = klass_at_impl(this_oop, index, CHECK_NULL); // ldc wants the java mirror. result_oop = resolved->java_mirror(); break; } case JVM_CONSTANT_String: assert(cache_index != _no_index_sentinel, "should have been set"); if (this_oop->is_pseudo_string_at(index)) { result_oop = this_oop->pseudo_string_at(index, cache_index); break; } result_oop = string_at_impl(this_oop, index, cache_index, CHECK_NULL); break; case JVM_CONSTANT_MethodHandleInError: case JVM_CONSTANT_MethodTypeInError: { Symbol* error = SystemDictionary::find_resolution_error(this_oop, index); guarantee(error != (Symbol*)NULL, "tag mismatch with resolution error table"); ResourceMark rm; THROW_MSG_0(error, ""); break; } case JVM_CONSTANT_MethodHandle: { int ref_kind = this_oop->method_handle_ref_kind_at(index); int callee_index = this_oop->method_handle_klass_index_at(index); Symbol* name = this_oop->method_handle_name_ref_at(index); Symbol* signature = this_oop->method_handle_signature_ref_at(index); if (PrintMiscellaneous) tty->print_cr("resolve JVM_CONSTANT_MethodHandle:%d [%d/%d/%d] %s.%s", ref_kind, index, this_oop->method_handle_index_at(index), callee_index, name->as_C_string(), signature->as_C_string()); KlassHandle callee; { Klass* k = klass_at_impl(this_oop, callee_index, CHECK_NULL); callee = KlassHandle(THREAD, k); } KlassHandle klass(THREAD, this_oop->pool_holder()); Handle value = SystemDictionary::link_method_handle_constant(klass, ref_kind, callee, name, signature, THREAD); result_oop = value(); if (HAS_PENDING_EXCEPTION) { save_and_throw_exception(this_oop, index, tag_value, CHECK_NULL); } break; } case JVM_CONSTANT_MethodType: { Symbol* signature = this_oop->method_type_signature_at(index); if (PrintMiscellaneous) tty->print_cr("resolve JVM_CONSTANT_MethodType [%d/%d] %s", index, this_oop->method_type_index_at(index), signature->as_C_string()); KlassHandle klass(THREAD, this_oop->pool_holder()); Handle value = SystemDictionary::find_method_handle_type(signature, klass, THREAD); result_oop = value(); if (HAS_PENDING_EXCEPTION) { save_and_throw_exception(this_oop, index, tag_value, CHECK_NULL); } break; } case JVM_CONSTANT_Integer: assert(cache_index == _no_index_sentinel, "should not have been set"); prim_value.i = this_oop->int_at(index); result_oop = java_lang_boxing_object::create(T_INT, &prim_value, CHECK_NULL); break; case JVM_CONSTANT_Float: assert(cache_index == _no_index_sentinel, "should not have been set"); prim_value.f = this_oop->float_at(index); result_oop = java_lang_boxing_object::create(T_FLOAT, &prim_value, CHECK_NULL); break; case JVM_CONSTANT_Long: assert(cache_index == _no_index_sentinel, "should not have been set"); prim_value.j = this_oop->long_at(index); result_oop = java_lang_boxing_object::create(T_LONG, &prim_value, CHECK_NULL); break; case JVM_CONSTANT_Double: assert(cache_index == _no_index_sentinel, "should not have been set"); prim_value.d = this_oop->double_at(index); result_oop = java_lang_boxing_object::create(T_DOUBLE, &prim_value, CHECK_NULL); break; default: DEBUG_ONLY( tty->print_cr("*** %p: tag at CP[%d/%d] = %d", this_oop(), index, cache_index, tag_value) ); assert(false, "unexpected constant tag"); break; } if (cache_index >= 0) { // Cache the oop here also. Handle result_handle(THREAD, result_oop); MonitorLockerEx ml(this_oop->lock()); // don‘t know if we really need this oop result = this_oop->resolved_references()->obj_at(cache_index); // Benign race condition: resolved_references may already be filled in while we were trying to lock. // The important thing here is that all threads pick up the same result. // It doesn‘t matter which racing thread wins, as long as only one // result is used by all threads, and all future queries. // That result may be either a resolved constant or a failure exception. if (result == NULL) { this_oop->resolved_references()->obj_at_put(cache_index, result_handle()); return result_handle(); } else { // Return the winning thread‘s result. This can be different than // result_handle() for MethodHandles. return result; } } else { return result_oop; } } ------------------- oop ConstantPool::string_at_impl(constantPoolHandle this_oop, int which, int obj_index, TRAPS) { // If the string has already been interned, this entry will be non-null oop str = this_oop->resolved_references()->obj_at(obj_index); if (str != NULL) return str; Symbol* sym = this_oop->unresolved_string_at(which); str = StringTable::intern(sym, CHECK_(NULL)); this_oop->string_at_put(which, obj_index, str); assert(java_lang_String::is_instance(str), "must be string"); return str; } ----- oop StringTable::intern(Symbol* symbol, TRAPS) { if (symbol == NULL) return NULL; ResourceMark rm(THREAD); int length; jchar* chars = symbol->as_unicode(length); Handle string; oop result = intern(string, chars, length, CHECK_NULL); return result; } ----- oop StringTable::intern(Handle string_or_null, jchar* name, int len, TRAPS) { unsigned int hashValue = hash_string(name, len); int index = the_table()->hash_to_index(hashValue); oop found_string = the_table()->lookup(index, name, len, hashValue); // Found if (found_string != NULL) return found_string; debug_only(StableMemoryChecker smc(name, len * sizeof(name[0]))); assert(!Universe::heap()->is_in_reserved(name), "proposed name of symbol must be stable"); Handle string; // try to reuse the string if possible if (!string_or_null.is_null()) { string = string_or_null; } else { string = java_lang_String::create_from_unicode(name, len, CHECK_NULL); } // Grab the StringTable_lock before getting the_table() because it could // change at safepoint. MutexLocker ml(StringTable_lock, THREAD); // Otherwise, add to symbol to table return the_table()->basic_add(index, string, name, len, hashValue, CHECK_NULL); } ----- oop StringTable::basic_add(int index_arg, Handle string, jchar* name, int len, unsigned int hashValue_arg, TRAPS) { assert(java_lang_String::equals(string(), name, len), "string must be properly initialized"); // Cannot hit a safepoint in this function because the "this" pointer can move. No_Safepoint_Verifier nsv; // Check if the symbol table has been rehashed, if so, need to recalculate // the hash value and index before second lookup. unsigned int hashValue; int index; if (use_alternate_hashcode()) { hashValue = hash_string(name, len); index = hash_to_index(hashValue); } else { hashValue = hashValue_arg; index = index_arg; } // Since look-up was done lock-free, we need to check if another // thread beat us in the race to insert the symbol. oop test = lookup(index, name, len, hashValue); // calls lookup(u1*, int) if (test != NULL) { // Entry already added return test; } HashtableEntry<oop, mtSymbol>* entry = new_entry(hashValue, string()); add_entry(index, entry); return string(); }
这下下就清楚了,这是气人,你重写代码,怎么不和我说一下呢
标签：enc alternate pat turn 源码解读 编译 字节码 || dcl
原文地址：https://www.cnblogs.com/zytcomeon/p/14699803.html
