void LIRGenerator::trace_block_entry(BlockBegin* block) {
__ move(LIR_OprFact::intConst(block->block_id()), FrameMap::O0_opr);
LIR_OprList* args = new LIR_OprList(1);
args->append(FrameMap::O0_opr);
address func = CAST_FROM_FN_PTR(address, Runtime1::trace_block_entry);
__ call_runtime_leaf(func, rlock_callee_saved(T_INT), LIR_OprFact::illegalOpr, args);
}
void LIRGenerator::do_NewMultiArray(NewMultiArray* x) {
Values* dims = x->dims();
int i = dims->length();
LIRItemList* items = new LIRItemList(dims->length(), NULL);
while (i-- > 0) {
LIRItem* size = new LIRItem(dims->at(i), this);
items->at_put(i, size);
}
// need to get the info before, as the items may become invalid through item_free
CodeEmitInfo* patching_info = NULL;
if (!x->klass()->is_loaded() || PatchALot) {
patching_info = state_for(x, x->state_before());
// cannot re-use same xhandlers for multiple CodeEmitInfos, so
// clone all handlers
x->set_exception_handlers(new XHandlers(x->exception_handlers()));
}
i = dims->length();
while (i-- > 0) {
LIRItem* size = items->at(i);
// if a patching_info was generated above then debug information for the state before
// the call is going to be emitted. The LIRGenerator calls above may have left some values
// in registers and that's been recorded in the CodeEmitInfo. In that case the items
// for those values can't simply be freed if they are registers because the values
// might be destroyed by store_stack_parameter. So in the case of patching, delay the
// freeing of the items that already were in registers
size->load_item();
store_stack_parameter (size->result(),
in_ByteSize(STACK_BIAS +
frame::memory_parameter_word_sp_offset * wordSize +
i * sizeof(jint)));
}
// This instruction can be deoptimized in the slow path : use
// O0 as result register.
const LIR_Opr reg = result_register_for(x->type());
CodeEmitInfo* info = state_for(x, x->state());
jobject2reg_with_patching(reg, x->klass(), patching_info);
LIR_Opr rank = FrameMap::O1_opr;
__ move(LIR_OprFact::intConst(x->rank()), rank);
LIR_Opr varargs = FrameMap::as_pointer_opr(O2);
int offset_from_sp = (frame::memory_parameter_word_sp_offset * wordSize) + STACK_BIAS;
__ add(FrameMap::SP_opr,
LIR_OprFact::intptrConst(offset_from_sp),
varargs);
LIR_OprList* args = new LIR_OprList(3);
args->append(reg);
args->append(rank);
args->append(varargs);
__ call_runtime(Runtime1::entry_for(Runtime1::new_multi_array_id),
LIR_OprFact::illegalOpr,
reg, args, info);
LIR_Opr result = rlock_result(x);
__ move(reg, result);
}
void LIRGenerator::do_NewMultiArray(NewMultiArray* x) {
Values* dims = x->dims();
int i = dims->length();
LIRItemList* items = new LIRItemList(dims->length(), NULL);
while (i-- > 0) {
LIRItem* size = new LIRItem(dims->at(i), this);
items->at_put(i, size);
}
// Evaluate state_for early since it may emit code.
CodeEmitInfo* patching_info = NULL;
if (!x->klass()->is_loaded() || PatchALot) {
patching_info = state_for(x, x->state_before());
// cannot re-use same xhandlers for multiple CodeEmitInfos, so
// clone all handlers. This is handled transparently in other
// places by the CodeEmitInfo cloning logic but is handled
// specially here because a stub isn't being used.
x->set_exception_handlers(new XHandlers(x->exception_handlers()));
}
CodeEmitInfo* info = state_for(x, x->state());
i = dims->length();
while (i-- > 0) {
LIRItem* size = items->at(i);
size->load_nonconstant();
store_stack_parameter(size->result(), in_ByteSize(i*4));
}
LIR_Opr reg = result_register_for(x->type());
jobject2reg_with_patching(reg, x->klass(), patching_info);
LIR_Opr rank = FrameMap::rbx_opr;
__ move(LIR_OprFact::intConst(x->rank()), rank);
LIR_Opr varargs = FrameMap::rcx_opr;
__ move(FrameMap::rsp_opr, varargs);
LIR_OprList* args = new LIR_OprList(3);
args->append(reg);
args->append(rank);
args->append(varargs);
__ call_runtime(Runtime1::entry_for(Runtime1::new_multi_array_id),
LIR_OprFact::illegalOpr,
reg, args, info);
LIR_Opr result = rlock_result(x);
__ move(reg, result);
}
CallingConvention* FrameMap::c_calling_convention(const BasicTypeArray* signature) {
// compute the size of the arguments first. The signature array
// that java_calling_convention takes includes a T_VOID after double
// work items but our signatures do not.
int i;
int sizeargs = 0;
for (i = 0; i < signature->length(); i++) {
sizeargs += type2size[signature->at(i)];
}
BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
int sig_index = 0;
for (i = 0; i < sizeargs; i++, sig_index++) {
sig_bt[i] = signature->at(sig_index);
if (sig_bt[i] == T_LONG || sig_bt[i] == T_DOUBLE) {
sig_bt[i + 1] = T_VOID;
i++;
}
}
intptr_t out_preserve = SharedRuntime::c_calling_convention(sig_bt, regs, NULL, sizeargs);
LIR_OprList* args = new LIR_OprList(signature->length());
for (i = 0; i < sizeargs;) {
BasicType t = sig_bt[i];
assert(t != T_VOID, "should be skipping these");
// C calls are always outgoing
bool outgoing = true;
LIR_Opr opr = map_to_opr(t, regs + i, outgoing);
// they might be of different types if for instance floating point
// values are passed in cpu registers, but the sizes must match.
assert(type2size[opr->type()] == type2size[t], "type mismatch");
args->append(opr);
if (opr->is_address()) {
LIR_Address* addr = opr->as_address_ptr();
out_preserve = MAX2(out_preserve, (intptr_t)(addr->disp() - STACK_BIAS) / 4);
}
i += type2size[t];
}
assert(args->length() == signature->length(), "size mismatch");
out_preserve += SharedRuntime::out_preserve_stack_slots();
update_reserved_argument_area_size(out_preserve * BytesPerWord);
return new CallingConvention(args, out_preserve);
}
CallingConvention* FrameMap::java_calling_convention(const BasicTypeArray* signature, bool outgoing) {
// compute the size of the arguments first. The signature array
// that java_calling_convention takes includes a T_VOID after double
// work items but our signatures do not.
int i;
int sizeargs = 0;
for (i = 0; i < signature->length(); i++) {
sizeargs += type2size[signature->at(i)];
}
BasicType* sig_bt = NEW_RESOURCE_ARRAY(BasicType, sizeargs);
VMRegPair* regs = NEW_RESOURCE_ARRAY(VMRegPair, sizeargs);
int sig_index = 0;
for (i = 0; i < sizeargs; i++, sig_index++) {
sig_bt[i] = signature->at(sig_index);
if (sig_bt[i] == T_LONG || sig_bt[i] == T_DOUBLE) {
sig_bt[i + 1] = T_VOID;
i++;
}
}
intptr_t out_preserve = SharedRuntime::java_calling_convention(sig_bt, regs, sizeargs, outgoing);
LIR_OprList* args = new LIR_OprList(signature->length());
for (i = 0; i < sizeargs;) {
BasicType t = sig_bt[i];
assert(t != T_VOID, "should be skipping these");
LIR_Opr opr = map_to_opr(t, regs + i, outgoing);
args->append(opr);
if (opr->is_address()) {
LIR_Address* addr = opr->as_address_ptr();
assert(addr->disp() == (int)addr->disp(), "out of range value");
out_preserve = MAX2(out_preserve, (intptr_t)(addr->disp() - STACK_BIAS) / 4);
}
i += type2size[t];
}
assert(args->length() == signature->length(), "size mismatch");
out_preserve += SharedRuntime::out_preserve_stack_slots();
if (outgoing) {
// update the space reserved for arguments.
update_reserved_argument_area_size(out_preserve * BytesPerWord);
}
return new CallingConvention(args, out_preserve);
}
