< prev index next >

src/hotspot/cpu/aarch64/macroAssembler_aarch64.hpp

Print this page

 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);
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:
< prev index next >