1176 }
1177 leave(); // remove frame anchor
1178 pop(ret_addr); // get return address
1179 mov(rsp, rbx); // set sp to sender sp
1180 }
1181
1182 void InterpreterMacroAssembler::get_method_counters(Register method,
1183 Register mcs, Label& skip) {
1184 Label has_counters;
1185 movptr(mcs, Address(method, Method::method_counters_offset()));
1186 testptr(mcs, mcs);
1187 jcc(Assembler::notZero, has_counters);
1188 call_VM(noreg, CAST_FROM_FN_PTR(address,
1189 InterpreterRuntime::build_method_counters), method);
1190 movptr(mcs, Address(method,Method::method_counters_offset()));
1191 testptr(mcs, mcs);
1192 jcc(Assembler::zero, skip); // No MethodCounters allocated, OutOfMemory
1193 bind(has_counters);
1194 }
1195
1196
1197 // Lock object
1198 //
1199 // Args:
1200 // rdx, c_rarg1: BasicObjectLock to be used for locking
1201 //
1202 // Kills:
1203 // rax, rbx
1204 void InterpreterMacroAssembler::lock_object(Register lock_reg) {
1205 assert(lock_reg == LP64_ONLY(c_rarg1) NOT_LP64(rdx),
1206 "The argument is only for looks. It must be c_rarg1");
1207
1208 if (UseHeavyMonitors) {
1209 call_VM(noreg,
1210 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
1211 lock_reg);
1212 } else {
1213 Label done;
1214
1215 const Register swap_reg = rax; // Must use rax for cmpxchg instruction
|
1176 }
1177 leave(); // remove frame anchor
1178 pop(ret_addr); // get return address
1179 mov(rsp, rbx); // set sp to sender sp
1180 }
1181
1182 void InterpreterMacroAssembler::get_method_counters(Register method,
1183 Register mcs, Label& skip) {
1184 Label has_counters;
1185 movptr(mcs, Address(method, Method::method_counters_offset()));
1186 testptr(mcs, mcs);
1187 jcc(Assembler::notZero, has_counters);
1188 call_VM(noreg, CAST_FROM_FN_PTR(address,
1189 InterpreterRuntime::build_method_counters), method);
1190 movptr(mcs, Address(method,Method::method_counters_offset()));
1191 testptr(mcs, mcs);
1192 jcc(Assembler::zero, skip); // No MethodCounters allocated, OutOfMemory
1193 bind(has_counters);
1194 }
1195
1196 void InterpreterMacroAssembler::allocate_instance(Register klass, Register new_obj,
1197 Register t1, Register t2,
1198 bool clear_fields, Label& alloc_failed) {
1199 MacroAssembler::allocate_instance(klass, new_obj, t1, t2, clear_fields, alloc_failed);
1200 {
1201 SkipIfEqual skip_if(this, &DTraceAllocProbes, 0);
1202 // Trigger dtrace event for fastpath
1203 push(atos);
1204 call_VM_leaf(CAST_FROM_FN_PTR(address, SharedRuntime::dtrace_object_alloc), new_obj);
1205 pop(atos);
1206 }
1207 }
1208
1209
1210 void InterpreterMacroAssembler::read_flattened_field(Register holder_klass,
1211 Register field_index, Register field_offset,
1212 Register obj) {
1213 Label alloc_failed, empty_value, done;
1214 const Register src = field_offset;
1215 const Register alloc_temp = LP64_ONLY(rscratch1) NOT_LP64(rsi);
1216 const Register dst_temp = LP64_ONLY(rscratch2) NOT_LP64(rdi);
1217 assert_different_registers(obj, holder_klass, field_index, field_offset, dst_temp);
1218
1219 // Grap the inline field klass
1220 push(holder_klass);
1221 const Register field_klass = holder_klass;
1222 get_value_field_klass(holder_klass, field_index, field_klass);
1223
1224 //check for empty value klass
1225 test_klass_is_empty_value(field_klass, dst_temp, empty_value);
1226
1227 // allocate buffer
1228 push(obj); // save holder
1229 allocate_instance(field_klass, obj, alloc_temp, dst_temp, false, alloc_failed);
1230
1231 // Have a oop instance buffer, copy into it
1232 data_for_oop(obj, dst_temp, field_klass);
1233 pop(alloc_temp); // restore holder
1234 lea(src, Address(alloc_temp, field_offset));
1235 // call_VM_leaf, clobbers a few regs, save restore new obj
1236 push(obj);
1237 access_value_copy(IS_DEST_UNINITIALIZED, src, dst_temp, field_klass);
1238 pop(obj);
1239 pop(holder_klass);
1240 jmp(done);
1241
1242 bind(empty_value);
1243 get_empty_value_oop(field_klass, dst_temp, obj);
1244 pop(holder_klass);
1245 jmp(done);
1246
1247 bind(alloc_failed);
1248 pop(obj);
1249 pop(holder_klass);
1250 call_VM(obj, CAST_FROM_FN_PTR(address, InterpreterRuntime::read_flattened_field),
1251 obj, field_index, holder_klass);
1252
1253 bind(done);
1254 }
1255
1256 // Lock object
1257 //
1258 // Args:
1259 // rdx, c_rarg1: BasicObjectLock to be used for locking
1260 //
1261 // Kills:
1262 // rax, rbx
1263 void InterpreterMacroAssembler::lock_object(Register lock_reg) {
1264 assert(lock_reg == LP64_ONLY(c_rarg1) NOT_LP64(rdx),
1265 "The argument is only for looks. It must be c_rarg1");
1266
1267 if (UseHeavyMonitors) {
1268 call_VM(noreg,
1269 CAST_FROM_FN_PTR(address, InterpreterRuntime::monitorenter),
1270 lock_reg);
1271 } else {
1272 Label done;
1273
1274 const Register swap_reg = rax; // Must use rax for cmpxchg instruction
|