3894
3895 bind(filtered);
3896 }
3897
3898 #endif // INCLUDE_ALL_GCS
3899 ///////////////////////////////////////////////////////////////////////////////////
3900
3901 void MacroAssembler::card_write_barrier_post(Register store_addr, Register new_val, Register tmp) {
3902 // If we're writing constant NULL, we can skip the write barrier.
3903 if (new_val == G0) return;
3904 CardTableModRefBS* bs = (CardTableModRefBS*) Universe::heap()->barrier_set();
3905 assert(bs->kind() == BarrierSet::CardTableModRef ||
3906 bs->kind() == BarrierSet::CardTableExtension, "wrong barrier");
3907 card_table_write(bs->byte_map_base, tmp, store_addr);
3908 }
3909
3910 void MacroAssembler::load_klass(Register src_oop, Register klass) {
3911 // The number of bytes in this code is used by
3912 // MachCallDynamicJavaNode::ret_addr_offset()
3913 // if this changes, change that.
3914 if (UseCompressedKlassPointers) {
3915 lduw(src_oop, oopDesc::klass_offset_in_bytes(), klass);
3916 decode_klass_not_null(klass);
3917 } else {
3918 ld_ptr(src_oop, oopDesc::klass_offset_in_bytes(), klass);
3919 }
3920 }
3921
3922 void MacroAssembler::store_klass(Register klass, Register dst_oop) {
3923 if (UseCompressedKlassPointers) {
3924 assert(dst_oop != klass, "not enough registers");
3925 encode_klass_not_null(klass);
3926 st(klass, dst_oop, oopDesc::klass_offset_in_bytes());
3927 } else {
3928 st_ptr(klass, dst_oop, oopDesc::klass_offset_in_bytes());
3929 }
3930 }
3931
3932 void MacroAssembler::store_klass_gap(Register s, Register d) {
3933 if (UseCompressedKlassPointers) {
3934 assert(s != d, "not enough registers");
3935 st(s, d, oopDesc::klass_gap_offset_in_bytes());
3936 }
3937 }
3938
3939 void MacroAssembler::load_heap_oop(const Address& s, Register d) {
3940 if (UseCompressedOops) {
3941 lduw(s, d);
3942 decode_heap_oop(d);
3943 } else {
3944 ld_ptr(s, d);
3945 }
3946 }
3947
3948 void MacroAssembler::load_heap_oop(Register s1, Register s2, Register d) {
3949 if (UseCompressedOops) {
3950 lduw(s1, s2, d);
3951 decode_heap_oop(d, d);
3952 } else {
3953 ld_ptr(s1, s2, d);
4072 assert (UseCompressedOops, "must be compressed");
4073 assert (Universe::heap() != NULL, "java heap should be initialized");
4074 assert (LogMinObjAlignmentInBytes == Universe::narrow_oop_shift(), "decode alg wrong");
4075 sllx(r, LogMinObjAlignmentInBytes, r);
4076 if (Universe::narrow_oop_base() != NULL)
4077 add(r, G6_heapbase, r);
4078 }
4079
4080 void MacroAssembler::decode_heap_oop_not_null(Register src, Register dst) {
4081 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
4082 // pd_code_size_limit.
4083 // Also do not verify_oop as this is called by verify_oop.
4084 assert (UseCompressedOops, "must be compressed");
4085 assert (LogMinObjAlignmentInBytes == Universe::narrow_oop_shift(), "decode alg wrong");
4086 sllx(src, LogMinObjAlignmentInBytes, dst);
4087 if (Universe::narrow_oop_base() != NULL)
4088 add(dst, G6_heapbase, dst);
4089 }
4090
4091 void MacroAssembler::encode_klass_not_null(Register r) {
4092 assert (UseCompressedKlassPointers, "must be compressed");
4093 assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
4094 assert(r != G6_heapbase, "bad register choice");
4095 set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
4096 sub(r, G6_heapbase, r);
4097 if (Universe::narrow_klass_shift() != 0) {
4098 assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
4099 srlx(r, LogKlassAlignmentInBytes, r);
4100 }
4101 reinit_heapbase();
4102 }
4103
4104 void MacroAssembler::encode_klass_not_null(Register src, Register dst) {
4105 if (src == dst) {
4106 encode_klass_not_null(src);
4107 } else {
4108 assert (UseCompressedKlassPointers, "must be compressed");
4109 assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
4110 set((intptr_t)Universe::narrow_klass_base(), dst);
4111 sub(src, dst, dst);
4112 if (Universe::narrow_klass_shift() != 0) {
4113 srlx(dst, LogKlassAlignmentInBytes, dst);
4114 }
4115 }
4116 }
4117
4118 // Function instr_size_for_decode_klass_not_null() counts the instructions
4119 // generated by decode_klass_not_null() and reinit_heapbase(). Hence, if
4120 // the instructions they generate change, then this method needs to be updated.
4121 int MacroAssembler::instr_size_for_decode_klass_not_null() {
4122 assert (UseCompressedKlassPointers, "only for compressed klass ptrs");
4123 // set + add + set
4124 int num_instrs = insts_for_internal_set((intptr_t)Universe::narrow_klass_base()) + 1 +
4125 insts_for_internal_set((intptr_t)Universe::narrow_ptrs_base());
4126 if (Universe::narrow_klass_shift() == 0) {
4127 return num_instrs * BytesPerInstWord;
4128 } else { // sllx
4129 return (num_instrs + 1) * BytesPerInstWord;
4130 }
4131 }
4132
4133 // !!! If the instructions that get generated here change then function
4134 // instr_size_for_decode_klass_not_null() needs to get updated.
4135 void MacroAssembler::decode_klass_not_null(Register r) {
4136 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
4137 // pd_code_size_limit.
4138 assert (UseCompressedKlassPointers, "must be compressed");
4139 assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
4140 assert(r != G6_heapbase, "bad register choice");
4141 set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
4142 if (Universe::narrow_klass_shift() != 0)
4143 sllx(r, LogKlassAlignmentInBytes, r);
4144 add(r, G6_heapbase, r);
4145 reinit_heapbase();
4146 }
4147
4148 void MacroAssembler::decode_klass_not_null(Register src, Register dst) {
4149 if (src == dst) {
4150 decode_klass_not_null(src);
4151 } else {
4152 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
4153 // pd_code_size_limit.
4154 assert (UseCompressedKlassPointers, "must be compressed");
4155 assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
4156 if (Universe::narrow_klass_shift() != 0) {
4157 assert((src != G6_heapbase) && (dst != G6_heapbase), "bad register choice");
4158 set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
4159 sllx(src, LogKlassAlignmentInBytes, dst);
4160 add(dst, G6_heapbase, dst);
4161 reinit_heapbase();
4162 } else {
4163 set((intptr_t)Universe::narrow_klass_base(), dst);
4164 add(src, dst, dst);
4165 }
4166 }
4167 }
4168
4169 void MacroAssembler::reinit_heapbase() {
4170 if (UseCompressedOops || UseCompressedKlassPointers) {
4171 if (Universe::heap() != NULL) {
4172 set((intptr_t)Universe::narrow_ptrs_base(), G6_heapbase);
4173 } else {
4174 AddressLiteral base(Universe::narrow_ptrs_base_addr());
4175 load_ptr_contents(base, G6_heapbase);
4176 }
4177 }
4178 }
4179
4180 // Compare char[] arrays aligned to 4 bytes.
4181 void MacroAssembler::char_arrays_equals(Register ary1, Register ary2,
4182 Register limit, Register result,
4183 Register chr1, Register chr2, Label& Ldone) {
4184 Label Lvector, Lloop;
4185 assert(chr1 == result, "should be the same");
4186
4187 // Note: limit contains number of bytes (2*char_elements) != 0.
4188 andcc(limit, 0x2, chr1); // trailing character ?
4189 br(Assembler::zero, false, Assembler::pt, Lvector);
4190 delayed()->nop();
|
3894
3895 bind(filtered);
3896 }
3897
3898 #endif // INCLUDE_ALL_GCS
3899 ///////////////////////////////////////////////////////////////////////////////////
3900
3901 void MacroAssembler::card_write_barrier_post(Register store_addr, Register new_val, Register tmp) {
3902 // If we're writing constant NULL, we can skip the write barrier.
3903 if (new_val == G0) return;
3904 CardTableModRefBS* bs = (CardTableModRefBS*) Universe::heap()->barrier_set();
3905 assert(bs->kind() == BarrierSet::CardTableModRef ||
3906 bs->kind() == BarrierSet::CardTableExtension, "wrong barrier");
3907 card_table_write(bs->byte_map_base, tmp, store_addr);
3908 }
3909
3910 void MacroAssembler::load_klass(Register src_oop, Register klass) {
3911 // The number of bytes in this code is used by
3912 // MachCallDynamicJavaNode::ret_addr_offset()
3913 // if this changes, change that.
3914 if (UseCompressedClassPointers) {
3915 lduw(src_oop, oopDesc::klass_offset_in_bytes(), klass);
3916 decode_klass_not_null(klass);
3917 } else {
3918 ld_ptr(src_oop, oopDesc::klass_offset_in_bytes(), klass);
3919 }
3920 }
3921
3922 void MacroAssembler::store_klass(Register klass, Register dst_oop) {
3923 if (UseCompressedClassPointers) {
3924 assert(dst_oop != klass, "not enough registers");
3925 encode_klass_not_null(klass);
3926 st(klass, dst_oop, oopDesc::klass_offset_in_bytes());
3927 } else {
3928 st_ptr(klass, dst_oop, oopDesc::klass_offset_in_bytes());
3929 }
3930 }
3931
3932 void MacroAssembler::store_klass_gap(Register s, Register d) {
3933 if (UseCompressedClassPointers) {
3934 assert(s != d, "not enough registers");
3935 st(s, d, oopDesc::klass_gap_offset_in_bytes());
3936 }
3937 }
3938
3939 void MacroAssembler::load_heap_oop(const Address& s, Register d) {
3940 if (UseCompressedOops) {
3941 lduw(s, d);
3942 decode_heap_oop(d);
3943 } else {
3944 ld_ptr(s, d);
3945 }
3946 }
3947
3948 void MacroAssembler::load_heap_oop(Register s1, Register s2, Register d) {
3949 if (UseCompressedOops) {
3950 lduw(s1, s2, d);
3951 decode_heap_oop(d, d);
3952 } else {
3953 ld_ptr(s1, s2, d);
4072 assert (UseCompressedOops, "must be compressed");
4073 assert (Universe::heap() != NULL, "java heap should be initialized");
4074 assert (LogMinObjAlignmentInBytes == Universe::narrow_oop_shift(), "decode alg wrong");
4075 sllx(r, LogMinObjAlignmentInBytes, r);
4076 if (Universe::narrow_oop_base() != NULL)
4077 add(r, G6_heapbase, r);
4078 }
4079
4080 void MacroAssembler::decode_heap_oop_not_null(Register src, Register dst) {
4081 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
4082 // pd_code_size_limit.
4083 // Also do not verify_oop as this is called by verify_oop.
4084 assert (UseCompressedOops, "must be compressed");
4085 assert (LogMinObjAlignmentInBytes == Universe::narrow_oop_shift(), "decode alg wrong");
4086 sllx(src, LogMinObjAlignmentInBytes, dst);
4087 if (Universe::narrow_oop_base() != NULL)
4088 add(dst, G6_heapbase, dst);
4089 }
4090
4091 void MacroAssembler::encode_klass_not_null(Register r) {
4092 assert (UseCompressedClassPointers, "must be compressed");
4093 assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
4094 assert(r != G6_heapbase, "bad register choice");
4095 set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
4096 sub(r, G6_heapbase, r);
4097 if (Universe::narrow_klass_shift() != 0) {
4098 assert (LogKlassAlignmentInBytes == Universe::narrow_klass_shift(), "decode alg wrong");
4099 srlx(r, LogKlassAlignmentInBytes, r);
4100 }
4101 reinit_heapbase();
4102 }
4103
4104 void MacroAssembler::encode_klass_not_null(Register src, Register dst) {
4105 if (src == dst) {
4106 encode_klass_not_null(src);
4107 } else {
4108 assert (UseCompressedClassPointers, "must be compressed");
4109 assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
4110 set((intptr_t)Universe::narrow_klass_base(), dst);
4111 sub(src, dst, dst);
4112 if (Universe::narrow_klass_shift() != 0) {
4113 srlx(dst, LogKlassAlignmentInBytes, dst);
4114 }
4115 }
4116 }
4117
4118 // Function instr_size_for_decode_klass_not_null() counts the instructions
4119 // generated by decode_klass_not_null() and reinit_heapbase(). Hence, if
4120 // the instructions they generate change, then this method needs to be updated.
4121 int MacroAssembler::instr_size_for_decode_klass_not_null() {
4122 assert (UseCompressedClassPointers, "only for compressed klass ptrs");
4123 // set + add + set
4124 int num_instrs = insts_for_internal_set((intptr_t)Universe::narrow_klass_base()) + 1 +
4125 insts_for_internal_set((intptr_t)Universe::narrow_ptrs_base());
4126 if (Universe::narrow_klass_shift() == 0) {
4127 return num_instrs * BytesPerInstWord;
4128 } else { // sllx
4129 return (num_instrs + 1) * BytesPerInstWord;
4130 }
4131 }
4132
4133 // !!! If the instructions that get generated here change then function
4134 // instr_size_for_decode_klass_not_null() needs to get updated.
4135 void MacroAssembler::decode_klass_not_null(Register r) {
4136 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
4137 // pd_code_size_limit.
4138 assert (UseCompressedClassPointers, "must be compressed");
4139 assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
4140 assert(r != G6_heapbase, "bad register choice");
4141 set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
4142 if (Universe::narrow_klass_shift() != 0)
4143 sllx(r, LogKlassAlignmentInBytes, r);
4144 add(r, G6_heapbase, r);
4145 reinit_heapbase();
4146 }
4147
4148 void MacroAssembler::decode_klass_not_null(Register src, Register dst) {
4149 if (src == dst) {
4150 decode_klass_not_null(src);
4151 } else {
4152 // Do not add assert code to this unless you change vtableStubs_sparc.cpp
4153 // pd_code_size_limit.
4154 assert (UseCompressedClassPointers, "must be compressed");
4155 assert(Universe::narrow_klass_base() != NULL, "narrow_klass_base should be initialized");
4156 if (Universe::narrow_klass_shift() != 0) {
4157 assert((src != G6_heapbase) && (dst != G6_heapbase), "bad register choice");
4158 set((intptr_t)Universe::narrow_klass_base(), G6_heapbase);
4159 sllx(src, LogKlassAlignmentInBytes, dst);
4160 add(dst, G6_heapbase, dst);
4161 reinit_heapbase();
4162 } else {
4163 set((intptr_t)Universe::narrow_klass_base(), dst);
4164 add(src, dst, dst);
4165 }
4166 }
4167 }
4168
4169 void MacroAssembler::reinit_heapbase() {
4170 if (UseCompressedOops || UseCompressedClassPointers) {
4171 if (Universe::heap() != NULL) {
4172 set((intptr_t)Universe::narrow_ptrs_base(), G6_heapbase);
4173 } else {
4174 AddressLiteral base(Universe::narrow_ptrs_base_addr());
4175 load_ptr_contents(base, G6_heapbase);
4176 }
4177 }
4178 }
4179
4180 // Compare char[] arrays aligned to 4 bytes.
4181 void MacroAssembler::char_arrays_equals(Register ary1, Register ary2,
4182 Register limit, Register result,
4183 Register chr1, Register chr2, Label& Ldone) {
4184 Label Lvector, Lloop;
4185 assert(chr1 == result, "should be the same");
4186
4187 // Note: limit contains number of bytes (2*char_elements) != 0.
4188 andcc(limit, 0x2, chr1); // trailing character ?
4189 br(Assembler::zero, false, Assembler::pt, Lvector);
4190 delayed()->nop();
|