806 Register scratch);
807
808 void reset_last_Java_frame(Register thread);
809
810 // thread in the default location (rthread)
811 void reset_last_Java_frame(bool clear_fp);
812
813 // Stores
814 void store_check(Register obj); // store check for obj - register is destroyed afterwards
815 void store_check(Register obj, Address dst); // same as above, dst is exact store location (reg. is destroyed)
816
817 void resolve_jobject(Register value, Register thread, Register tmp);
818
819 // C 'boolean' to Java boolean: x == 0 ? 0 : 1
820 void c2bool(Register x);
821
822 void load_method_holder_cld(Register rresult, Register rmethod);
823 void load_method_holder(Register holder, Register method);
824
825 // oop manipulations
826 void load_klass(Register dst, Register src);
827 void store_klass(Register dst, Register src);
828 void cmp_klass(Register oop, Register trial_klass, Register tmp);
829
830 void resolve_weak_handle(Register result, Register tmp);
831 void resolve_oop_handle(Register result, Register tmp = r5);
832 void load_mirror(Register dst, Register method, Register tmp = r5);
833
834 void access_load_at(BasicType type, DecoratorSet decorators, Register dst, Address src,
835 Register tmp1, Register tmp_thread);
836
837 void access_store_at(BasicType type, DecoratorSet decorators, Address dst, Register src,
838 Register tmp1, Register tmp_thread);
839
840 void load_heap_oop(Register dst, Address src, Register tmp1 = noreg,
841 Register thread_tmp = noreg, DecoratorSet decorators = 0);
842
843 void load_heap_oop_not_null(Register dst, Address src, Register tmp1 = noreg,
844 Register thread_tmp = noreg, DecoratorSet decorators = 0);
845 void store_heap_oop(Address dst, Register src, Register tmp1 = noreg,
846 Register tmp_thread = noreg, DecoratorSet decorators = 0);
847
848 // currently unimplemented
849 // Used for storing NULL. All other oop constants should be
850 // stored using routines that take a jobject.
851 void store_heap_oop_null(Address dst);
852
853 void load_prototype_header(Register dst, Register src);
854
855 void store_klass_gap(Register dst, Register src);
856
857 // This dummy is to prevent a call to store_heap_oop from
858 // converting a zero (like NULL) into a Register by giving
859 // the compiler two choices it can't resolve
860
861 void store_heap_oop(Address dst, void* dummy);
862
863 void encode_heap_oop(Register d, Register s);
864 void encode_heap_oop(Register r) { encode_heap_oop(r, r); }
865 void decode_heap_oop(Register d, Register s);
866 void decode_heap_oop(Register r) { decode_heap_oop(r, r); }
867 void encode_heap_oop_not_null(Register r);
868 void decode_heap_oop_not_null(Register r);
869 void encode_heap_oop_not_null(Register dst, Register src);
870 void decode_heap_oop_not_null(Register dst, Register src);
871
872 void set_narrow_oop(Register dst, jobject obj);
873
874 void encode_klass_not_null(Register r);
875 void decode_klass_not_null(Register r);
876 void encode_klass_not_null(Register dst, Register src);
1403 spill(tmp1, true, dst_offset);
1404 unspill(tmp1, true, src_offset+8);
1405 spill(tmp1, true, dst_offset+8);
1406 }
1407 }
1408 void spill_copy_sve_vector_stack_to_stack(int src_offset, int dst_offset,
1409 int sve_vec_reg_size_in_bytes) {
1410 assert(sve_vec_reg_size_in_bytes % 16 == 0, "unexpected sve vector reg size");
1411 for (int i = 0; i < sve_vec_reg_size_in_bytes / 16; i++) {
1412 spill_copy128(src_offset, dst_offset);
1413 src_offset += 16;
1414 dst_offset += 16;
1415 }
1416 }
1417 void cache_wb(Address line);
1418 void cache_wbsync(bool is_pre);
1419
1420 // Code for java.lang.Thread::onSpinWait() intrinsic.
1421 void spin_wait();
1422
1423 private:
1424 // Check the current thread doesn't need a cross modify fence.
1425 void verify_cross_modify_fence_not_required() PRODUCT_RETURN;
1426
1427 };
1428
1429 #ifdef ASSERT
1430 inline bool AbstractAssembler::pd_check_instruction_mark() { return false; }
1431 #endif
1432
1433 /**
1434 * class SkipIfEqual:
1435 *
1436 * Instantiating this class will result in assembly code being output that will
1437 * jump around any code emitted between the creation of the instance and it's
1438 * automatic destruction at the end of a scope block, depending on the value of
1439 * the flag passed to the constructor, which will be checked at run-time.
1440 */
1441 class SkipIfEqual {
1442 private:
|
806 Register scratch);
807
808 void reset_last_Java_frame(Register thread);
809
810 // thread in the default location (rthread)
811 void reset_last_Java_frame(bool clear_fp);
812
813 // Stores
814 void store_check(Register obj); // store check for obj - register is destroyed afterwards
815 void store_check(Register obj, Address dst); // same as above, dst is exact store location (reg. is destroyed)
816
817 void resolve_jobject(Register value, Register thread, Register tmp);
818
819 // C 'boolean' to Java boolean: x == 0 ? 0 : 1
820 void c2bool(Register x);
821
822 void load_method_holder_cld(Register rresult, Register rmethod);
823 void load_method_holder(Register holder, Register method);
824
825 // oop manipulations
826 void load_nklass(Register dst, Register src);
827 void load_klass(Register dst, Register src, bool null_check = false);
828 void store_klass(Register dst, Register src);
829 void cmp_klass(Register oop, Register trial_klass, Register tmp);
830
831 void resolve_weak_handle(Register result, Register tmp);
832 void resolve_oop_handle(Register result, Register tmp = r5);
833 void load_mirror(Register dst, Register method, Register tmp = r5);
834
835 void access_load_at(BasicType type, DecoratorSet decorators, Register dst, Address src,
836 Register tmp1, Register tmp_thread);
837
838 void access_store_at(BasicType type, DecoratorSet decorators, Address dst, Register src,
839 Register tmp1, Register tmp_thread);
840
841 void load_heap_oop(Register dst, Address src, Register tmp1 = noreg,
842 Register thread_tmp = noreg, DecoratorSet decorators = 0);
843
844 void load_heap_oop_not_null(Register dst, Address src, Register tmp1 = noreg,
845 Register thread_tmp = noreg, DecoratorSet decorators = 0);
846 void store_heap_oop(Address dst, Register src, Register tmp1 = noreg,
847 Register tmp_thread = noreg, DecoratorSet decorators = 0);
848
849 // currently unimplemented
850 // Used for storing NULL. All other oop constants should be
851 // stored using routines that take a jobject.
852 void store_heap_oop_null(Address dst);
853
854 void store_klass_gap(Register dst, Register src);
855
856 void load_prototype_header(Register dst, Register src);
857
858 // This dummy is to prevent a call to store_heap_oop from
859 // converting a zero (like NULL) into a Register by giving
860 // the compiler two choices it can't resolve
861
862 void store_heap_oop(Address dst, void* dummy);
863
864 void encode_heap_oop(Register d, Register s);
865 void encode_heap_oop(Register r) { encode_heap_oop(r, r); }
866 void decode_heap_oop(Register d, Register s);
867 void decode_heap_oop(Register r) { decode_heap_oop(r, r); }
868 void encode_heap_oop_not_null(Register r);
869 void decode_heap_oop_not_null(Register r);
870 void encode_heap_oop_not_null(Register dst, Register src);
871 void decode_heap_oop_not_null(Register dst, Register src);
872
873 void set_narrow_oop(Register dst, jobject obj);
874
875 void encode_klass_not_null(Register r);
876 void decode_klass_not_null(Register r);
877 void encode_klass_not_null(Register dst, Register src);
1404 spill(tmp1, true, dst_offset);
1405 unspill(tmp1, true, src_offset+8);
1406 spill(tmp1, true, dst_offset+8);
1407 }
1408 }
1409 void spill_copy_sve_vector_stack_to_stack(int src_offset, int dst_offset,
1410 int sve_vec_reg_size_in_bytes) {
1411 assert(sve_vec_reg_size_in_bytes % 16 == 0, "unexpected sve vector reg size");
1412 for (int i = 0; i < sve_vec_reg_size_in_bytes / 16; i++) {
1413 spill_copy128(src_offset, dst_offset);
1414 src_offset += 16;
1415 dst_offset += 16;
1416 }
1417 }
1418 void cache_wb(Address line);
1419 void cache_wbsync(bool is_pre);
1420
1421 // Code for java.lang.Thread::onSpinWait() intrinsic.
1422 void spin_wait();
1423
1424 void fast_lock(Register obj, Register hdr, Register t1, Register t2, Label& slow, bool rt_check_stack = true);
1425 void fast_unlock(Register obj, Register hdr, Register t1, Register t2, Label& slow);
1426
1427 private:
1428 // Check the current thread doesn't need a cross modify fence.
1429 void verify_cross_modify_fence_not_required() PRODUCT_RETURN;
1430
1431 };
1432
1433 #ifdef ASSERT
1434 inline bool AbstractAssembler::pd_check_instruction_mark() { return false; }
1435 #endif
1436
1437 /**
1438 * class SkipIfEqual:
1439 *
1440 * Instantiating this class will result in assembly code being output that will
1441 * jump around any code emitted between the creation of the instance and it's
1442 * automatic destruction at the end of a scope block, depending on the value of
1443 * the flag passed to the constructor, which will be checked at run-time.
1444 */
1445 class SkipIfEqual {
1446 private:
|