2957 } |
2957 } |
2958 } |
2958 } |
2959 #endif // !LP64 || C1 || !C2 || INCLUDE_JVMCI |
2959 #endif // !LP64 || C1 || !C2 || INCLUDE_JVMCI |
2960 |
2960 |
2961 |
2961 |
2962 // Defines obj, preserves var_size_in_bytes |
|
2963 void MacroAssembler::eden_allocate(Register obj, |
|
2964 Register var_size_in_bytes, |
|
2965 int con_size_in_bytes, |
|
2966 Register t1, |
|
2967 Label& slow_case) { |
|
2968 assert(obj == rax, "obj must be in rax, for cmpxchg"); |
|
2969 assert_different_registers(obj, var_size_in_bytes, t1); |
|
2970 if (!Universe::heap()->supports_inline_contig_alloc()) { |
|
2971 jmp(slow_case); |
|
2972 } else { |
|
2973 Register end = t1; |
|
2974 Label retry; |
|
2975 bind(retry); |
|
2976 ExternalAddress heap_top((address) Universe::heap()->top_addr()); |
|
2977 movptr(obj, heap_top); |
|
2978 if (var_size_in_bytes == noreg) { |
|
2979 lea(end, Address(obj, con_size_in_bytes)); |
|
2980 } else { |
|
2981 lea(end, Address(obj, var_size_in_bytes, Address::times_1)); |
|
2982 } |
|
2983 // if end < obj then we wrapped around => object too long => slow case |
|
2984 cmpptr(end, obj); |
|
2985 jcc(Assembler::below, slow_case); |
|
2986 cmpptr(end, ExternalAddress((address) Universe::heap()->end_addr())); |
|
2987 jcc(Assembler::above, slow_case); |
|
2988 // Compare obj with the top addr, and if still equal, store the new top addr in |
|
2989 // end at the address of the top addr pointer. Sets ZF if was equal, and clears |
|
2990 // it otherwise. Use lock prefix for atomicity on MPs. |
|
2991 locked_cmpxchgptr(end, heap_top); |
|
2992 jcc(Assembler::notEqual, retry); |
|
2993 } |
|
2994 } |
|
2995 |
|
2996 void MacroAssembler::enter() { |
2962 void MacroAssembler::enter() { |
2997 push(rbp); |
2963 push(rbp); |
2998 mov(rbp, rsp); |
2964 mov(rbp, rsp); |
2999 } |
2965 } |
3000 |
2966 |
5308 void MacroAssembler::testptr(Register dst, Register src) { |
5274 void MacroAssembler::testptr(Register dst, Register src) { |
5309 LP64_ONLY(testq(dst, src)) NOT_LP64(testl(dst, src)); |
5275 LP64_ONLY(testq(dst, src)) NOT_LP64(testl(dst, src)); |
5310 } |
5276 } |
5311 |
5277 |
5312 // Defines obj, preserves var_size_in_bytes, okay for t2 == var_size_in_bytes. |
5278 // Defines obj, preserves var_size_in_bytes, okay for t2 == var_size_in_bytes. |
5313 void MacroAssembler::tlab_allocate(Register obj, |
5279 void MacroAssembler::tlab_allocate(Register thread, Register obj, |
5314 Register var_size_in_bytes, |
5280 Register var_size_in_bytes, |
5315 int con_size_in_bytes, |
5281 int con_size_in_bytes, |
5316 Register t1, |
5282 Register t1, |
5317 Register t2, |
5283 Register t2, |
5318 Label& slow_case) { |
5284 Label& slow_case) { |
5319 assert_different_registers(obj, t1, t2); |
5285 BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler(); |
5320 assert_different_registers(obj, var_size_in_bytes, t1); |
5286 bs->tlab_allocate(this, thread, obj, var_size_in_bytes, con_size_in_bytes, t1, t2, slow_case); |
5321 Register end = t2; |
5287 } |
5322 Register thread = NOT_LP64(t1) LP64_ONLY(r15_thread); |
5288 |
5323 |
5289 // Defines obj, preserves var_size_in_bytes |
5324 verify_tlab(); |
5290 void MacroAssembler::eden_allocate(Register thread, Register obj, |
5325 |
5291 Register var_size_in_bytes, |
5326 NOT_LP64(get_thread(thread)); |
5292 int con_size_in_bytes, |
5327 |
5293 Register t1, |
5328 movptr(obj, Address(thread, JavaThread::tlab_top_offset())); |
5294 Label& slow_case) { |
5329 if (var_size_in_bytes == noreg) { |
5295 BarrierSetAssembler* bs = BarrierSet::barrier_set()->barrier_set_assembler(); |
5330 lea(end, Address(obj, con_size_in_bytes)); |
5296 bs->eden_allocate(this, thread, obj, var_size_in_bytes, con_size_in_bytes, t1, slow_case); |
5331 } else { |
|
5332 lea(end, Address(obj, var_size_in_bytes, Address::times_1)); |
|
5333 } |
|
5334 cmpptr(end, Address(thread, JavaThread::tlab_end_offset())); |
|
5335 jcc(Assembler::above, slow_case); |
|
5336 |
|
5337 // update the tlab top pointer |
|
5338 movptr(Address(thread, JavaThread::tlab_top_offset()), end); |
|
5339 |
|
5340 // recover var_size_in_bytes if necessary |
|
5341 if (var_size_in_bytes == end) { |
|
5342 subptr(var_size_in_bytes, obj); |
|
5343 } |
|
5344 verify_tlab(); |
|
5345 } |
5297 } |
5346 |
5298 |
5347 // Preserves the contents of address, destroys the contents length_in_bytes and temp. |
5299 // Preserves the contents of address, destroys the contents length_in_bytes and temp. |
5348 void MacroAssembler::zero_memory(Register address, Register length_in_bytes, int offset_in_bytes, Register temp) { |
5300 void MacroAssembler::zero_memory(Register address, Register length_in_bytes, int offset_in_bytes, Register temp) { |
5349 assert(address != length_in_bytes && address != temp && temp != length_in_bytes, "registers must be different"); |
5301 assert(address != length_in_bytes && address != temp && temp != length_in_bytes, "registers must be different"); |
5396 decrement(index); |
5348 decrement(index); |
5397 jcc(Assembler::notZero, loop); |
5349 jcc(Assembler::notZero, loop); |
5398 } |
5350 } |
5399 |
5351 |
5400 bind(done); |
5352 bind(done); |
5401 } |
|
5402 |
|
5403 void MacroAssembler::incr_allocated_bytes(Register thread, |
|
5404 Register var_size_in_bytes, |
|
5405 int con_size_in_bytes, |
|
5406 Register t1) { |
|
5407 if (!thread->is_valid()) { |
|
5408 #ifdef _LP64 |
|
5409 thread = r15_thread; |
|
5410 #else |
|
5411 assert(t1->is_valid(), "need temp reg"); |
|
5412 thread = t1; |
|
5413 get_thread(thread); |
|
5414 #endif |
|
5415 } |
|
5416 |
|
5417 #ifdef _LP64 |
|
5418 if (var_size_in_bytes->is_valid()) { |
|
5419 addq(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), var_size_in_bytes); |
|
5420 } else { |
|
5421 addq(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), con_size_in_bytes); |
|
5422 } |
|
5423 #else |
|
5424 if (var_size_in_bytes->is_valid()) { |
|
5425 addl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), var_size_in_bytes); |
|
5426 } else { |
|
5427 addl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())), con_size_in_bytes); |
|
5428 } |
|
5429 adcl(Address(thread, in_bytes(JavaThread::allocated_bytes_offset())+4), 0); |
|
5430 #endif |
|
5431 } |
5353 } |
5432 |
5354 |
5433 // Look up the method for a megamorphic invokeinterface call. |
5355 // Look up the method for a megamorphic invokeinterface call. |
5434 // The target method is determined by <intf_klass, itable_index>. |
5356 // The target method is determined by <intf_klass, itable_index>. |
5435 // The receiver klass is in recv_klass. |
5357 // The receiver klass is in recv_klass. |