< prev index next >

src/hotspot/cpu/aarch64/macroAssembler_aarch64.hpp

Print this page

 910 
 911   void set_narrow_oop(Register dst, jobject obj);
 912 
 913   void encode_klass_not_null(Register r);
 914   void decode_klass_not_null(Register r);
 915   void encode_klass_not_null(Register dst, Register src);
 916   void decode_klass_not_null(Register dst, Register src);
 917 
 918   void set_narrow_klass(Register dst, Klass* k);
 919 
 920   // if heap base register is used - reinit it with the correct value
 921   void reinit_heapbase();
 922 
 923   DEBUG_ONLY(void verify_heapbase(const char* msg);)
 924 
 925   void push_CPU_state(bool save_vectors = false, bool use_sve = false,
 926                       int sve_vector_size_in_bytes = 0, int total_predicate_in_bytes = 0);
 927   void pop_CPU_state(bool restore_vectors = false, bool use_sve = false,
 928                      int sve_vector_size_in_bytes = 0, int total_predicate_in_bytes = 0);
 929 
 930   void push_cont_fastpath(Register java_thread);
 931   void pop_cont_fastpath(Register java_thread);



 932 
 933   // Round up to a power of two
 934   void round_to(Register reg, int modulus);
 935 
 936   // java.lang.Math::round intrinsics
 937   void java_round_double(Register dst, FloatRegister src, FloatRegister ftmp);
 938   void java_round_float(Register dst, FloatRegister src, FloatRegister ftmp);
 939 
 940   // allocation
 941   void tlab_allocate(
 942     Register obj,                      // result: pointer to object after successful allocation
 943     Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise
 944     int      con_size_in_bytes,        // object size in bytes if   known at compile time
 945     Register t1,                       // temp register
 946     Register t2,                       // temp register
 947     Label&   slow_case                 // continuation point if fast allocation fails
 948   );
 949   void verify_tlab();
 950 
 951   // interface method calling

1036     if (VerifyOops) {
1037       _verify_oop_addr(reg, s, file, line);
1038     }
1039   }
1040 
1041 // TODO: verify method and klass metadata (compare against vptr?)
1042   void _verify_method_ptr(Register reg, const char * msg, const char * file, int line) {}
1043   void _verify_klass_ptr(Register reg, const char * msg, const char * file, int line){}
1044 
1045 #define verify_oop(reg) _verify_oop_checked(reg, "broken oop " #reg, __FILE__, __LINE__)
1046 #define verify_oop_msg(reg, msg) _verify_oop_checked(reg, "broken oop " #reg ", " #msg, __FILE__, __LINE__)
1047 #define verify_oop_addr(addr) _verify_oop_addr_checked(addr, "broken oop addr " #addr, __FILE__, __LINE__)
1048 #define verify_method_ptr(reg) _verify_method_ptr(reg, "broken method " #reg, __FILE__, __LINE__)
1049 #define verify_klass_ptr(reg) _verify_klass_ptr(reg, "broken klass " #reg, __FILE__, __LINE__)
1050 
1051   // Restore cpu control state after JNI call
1052   void restore_cpu_control_state_after_jni(Register tmp1, Register tmp2);
1053 
1054   // prints msg, dumps registers and stops execution
1055   void stop(const char* msg);

1056 
1057   static void debug64(char* msg, int64_t pc, int64_t regs[]);
1058 
1059   void untested()                                { stop("untested"); }
1060 
1061   void unimplemented(const char* what = "");
1062 
1063   void should_not_reach_here()                   { stop("should not reach here"); }
1064 
1065   void _assert_asm(Condition cc, const char* msg);
1066 #define assert_asm0(cc, msg) _assert_asm(cc, FILE_AND_LINE ": " msg)
1067 #define assert_asm(masm, command, cc, msg) DEBUG_ONLY(command; (masm)->_assert_asm(cc, FILE_AND_LINE ": " #command " " #cc ": " msg))
1068 
1069   // Stack overflow checking
1070   void bang_stack_with_offset(int offset) {
1071     // stack grows down, caller passes positive offset
1072     assert(offset > 0, "must bang with negative offset");
1073     sub(rscratch2, sp, offset);
1074     str(zr, Address(rscratch2));
1075   }

 910 
 911   void set_narrow_oop(Register dst, jobject obj);
 912 
 913   void encode_klass_not_null(Register r);
 914   void decode_klass_not_null(Register r);
 915   void encode_klass_not_null(Register dst, Register src);
 916   void decode_klass_not_null(Register dst, Register src);
 917 
 918   void set_narrow_klass(Register dst, Klass* k);
 919 
 920   // if heap base register is used - reinit it with the correct value
 921   void reinit_heapbase();
 922 
 923   DEBUG_ONLY(void verify_heapbase(const char* msg);)
 924 
 925   void push_CPU_state(bool save_vectors = false, bool use_sve = false,
 926                       int sve_vector_size_in_bytes = 0, int total_predicate_in_bytes = 0);
 927   void pop_CPU_state(bool restore_vectors = false, bool use_sve = false,
 928                      int sve_vector_size_in_bytes = 0, int total_predicate_in_bytes = 0);
 929 
 930   void push_cont_fastpath(Register java_thread = rthread);
 931   void pop_cont_fastpath(Register java_thread = rthread);
 932 
 933   void inc_held_monitor_count();
 934   void dec_held_monitor_count();
 935 
 936   // Round up to a power of two
 937   void round_to(Register reg, int modulus);
 938 
 939   // java.lang.Math::round intrinsics
 940   void java_round_double(Register dst, FloatRegister src, FloatRegister ftmp);
 941   void java_round_float(Register dst, FloatRegister src, FloatRegister ftmp);
 942 
 943   // allocation
 944   void tlab_allocate(
 945     Register obj,                      // result: pointer to object after successful allocation
 946     Register var_size_in_bytes,        // object size in bytes if unknown at compile time; invalid otherwise
 947     int      con_size_in_bytes,        // object size in bytes if   known at compile time
 948     Register t1,                       // temp register
 949     Register t2,                       // temp register
 950     Label&   slow_case                 // continuation point if fast allocation fails
 951   );
 952   void verify_tlab();
 953 
 954   // interface method calling

1039     if (VerifyOops) {
1040       _verify_oop_addr(reg, s, file, line);
1041     }
1042   }
1043 
1044 // TODO: verify method and klass metadata (compare against vptr?)
1045   void _verify_method_ptr(Register reg, const char * msg, const char * file, int line) {}
1046   void _verify_klass_ptr(Register reg, const char * msg, const char * file, int line){}
1047 
1048 #define verify_oop(reg) _verify_oop_checked(reg, "broken oop " #reg, __FILE__, __LINE__)
1049 #define verify_oop_msg(reg, msg) _verify_oop_checked(reg, "broken oop " #reg ", " #msg, __FILE__, __LINE__)
1050 #define verify_oop_addr(addr) _verify_oop_addr_checked(addr, "broken oop addr " #addr, __FILE__, __LINE__)
1051 #define verify_method_ptr(reg) _verify_method_ptr(reg, "broken method " #reg, __FILE__, __LINE__)
1052 #define verify_klass_ptr(reg) _verify_klass_ptr(reg, "broken klass " #reg, __FILE__, __LINE__)
1053 
1054   // Restore cpu control state after JNI call
1055   void restore_cpu_control_state_after_jni(Register tmp1, Register tmp2);
1056 
1057   // prints msg, dumps registers and stops execution
1058   void stop(const char* msg);
1059   void trace(const char* msg);
1060 
1061   static void debug64(char* msg, int64_t pc, int64_t regs[]);
1062 
1063   void untested()                                { stop("untested"); }
1064 
1065   void unimplemented(const char* what = "");
1066 
1067   void should_not_reach_here()                   { stop("should not reach here"); }
1068 
1069   void _assert_asm(Condition cc, const char* msg);
1070 #define assert_asm0(cc, msg) _assert_asm(cc, FILE_AND_LINE ": " msg)
1071 #define assert_asm(masm, command, cc, msg) DEBUG_ONLY(command; (masm)->_assert_asm(cc, FILE_AND_LINE ": " #command " " #cc ": " msg))
1072 
1073   // Stack overflow checking
1074   void bang_stack_with_offset(int offset) {
1075     // stack grows down, caller passes positive offset
1076     assert(offset > 0, "must bang with negative offset");
1077     sub(rscratch2, sp, offset);
1078     str(zr, Address(rscratch2));
1079   }
< prev index next >