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