void C2Compiler::initialize_runtime() {
// Check assumptions used while running ADLC
Compile::adlc_verification();
assert(REG_COUNT <= ConcreteRegisterImpl::number_of_registers, "incompatible register counts");
for (int i = 0; i < ConcreteRegisterImpl::number_of_registers ; i++ ) {
OptoReg::vm2opto[i] = OptoReg::Bad;
}
for( OptoReg::Name i=OptoReg::Name(0); i<OptoReg::Name(REG_COUNT); i = OptoReg::add(i,1) ) {
VMReg r = OptoReg::as_VMReg(i);
if (r->is_valid()) {
OptoReg::vm2opto[r->value()] = i;
}
}
// Check that runtime and architecture description agree on callee-saved-floats
bool callee_saved_floats = false;
for( OptoReg::Name i=OptoReg::Name(0); i<OptoReg::Name(_last_Mach_Reg); i = OptoReg::add(i,1) ) {
// Is there a callee-saved float or double?
if( register_save_policy[i] == 'E' /* callee-saved */ &&
(register_save_type[i] == Op_RegF || register_save_type[i] == Op_RegD) ) {
callee_saved_floats = true;
}
}
DEBUG_ONLY( Node::init_NodeProperty(); )
VMReg bias(int offset) {
assert(is_stack(), "must be");
// VMReg res = VMRegImpl::as_VMReg(value() + offset);
VMReg res = stack2reg(reg2stack() + offset);
assert(res->is_stack(), "must be");
return res;
}
void set_ptr ( VMReg ptr ) {
#ifdef _LP64
_second = ptr->next();
#else
_second = VMRegImpl::Bad();
#endif
_first = ptr;
}
void LIR_Assembler::verify_oop_map(CodeEmitInfo* info) {
#ifndef PRODUCT
if (VerifyOops) {
OopMapStream s(info->oop_map());
while (!s.is_done()) {
OopMapValue v = s.current();
if (v.is_oop()) {
VMReg r = v.reg();
if (!r->is_stack()) {
stringStream st;
st.print("bad oop %s at %d", r->as_Register()->name(), _masm->offset());
#ifdef SPARC
_masm->_verify_oop(r->as_Register(), os::strdup(st.as_string(), mtCompiler), __FILE__, __LINE__);
#else
_masm->verify_oop(r->as_Register());
#endif
} else {
_masm->verify_stack_oop(r->reg2stack() * VMRegImpl::stack_slot_size);
}
}
check_codespace();
CHECK_BAILOUT();
s.next();
}
}
#endif
}
address RegisterMap::pd_location(VMReg regname) const {
register_map_init();
assert(regname->is_reg(), "sanity check");
// Only the GPRs get handled this way
if( !regname->is_Register())
return NULL;
// don't talk about bad registers
if ((bad_mask & ((LocationValidType)1 << regname->value())) != 0) {
return NULL;
}
// Convert to a GPR
Register reg;
int second_word = 0;
// 32-bit registers for in, out and local
if (!regname->is_concrete()) {
// HMM ought to return NULL for any non-concrete (odd) vmreg
// this all tied up in the fact we put out double oopMaps for
// register locations. When that is fixed we'd will return NULL
// (or assert here).
reg = regname->prev()->as_Register();
#ifdef _LP64
second_word = sizeof(jint);
#else
return NULL;
#endif // _LP64
} else {
reg = regname->as_Register();
}
if (reg->is_out()) {
assert(_younger_window != NULL, "Younger window should be available");
return second_word + (address)&_younger_window[reg->after_save()->sp_offset_in_saved_window()];
}
if (reg->is_local() || reg->is_in()) {
assert(_window != NULL, "Window should be available");
return second_word + (address)&_window[reg->sp_offset_in_saved_window()];
}
// Only the window'd GPRs get handled this way; not the globals.
return NULL;
}
bool CodeInstaller::is_general_purpose_reg(VMReg hotspotRegister) {
return !hotspotRegister->is_FloatRegister();
}
// This really ought to check that the register is "real" in the sense that
// we don't try and get the VMReg number of a physical register that doesn't
// have an expressible part. That would be pd specific code
VMReg next() {
assert((is_reg() && value() < stack0->value() - 1) || is_stack(), "must be");
return (VMReg)(intptr_t)(value() + 1);
}
// Return true if single register but adjacent stack slots do not count
bool is_single_phys_reg() const {
return (_first->is_reg() && (_first->value() + 1 == _second->value()));
}
// Return true if single stack based "register" where the slot alignment matches input alignment
bool is_adjacent_aligned_on_stack(int alignment) const {
return (_first->is_stack() && (_first->value() + 1 == _second->value()) && ((_first->value() & (alignment-1)) == 0));
}
void set2 ( VMReg v ) {
_second=v->next();
_first=v;
}
uintptr_t reg2stack() {
assert( is_stack(), "Not a stack-based register" );
return value() - stack0->value();
}
// Convert register numbers to stack slots and vice versa
static VMReg stack2reg( int idx ) {
return (VMReg) (intptr_t) (stack0->value() + idx);
}
VMReg prev() {
assert((is_stack() && value() > stack0->value()) || (is_reg() && value() != 0), "must be");
return (VMReg)(intptr_t)(value() - 1);
}
// frame_size units are stack-slots (4 bytes) NOT intptr_t; we can name odd
// slots to hold 4-byte values like ints and floats in the LP64 build.
void OopMap::set_xxx(VMReg reg, OopMapValue::oop_types x, VMReg optional) {
assert(reg->value() < _locs_length, "too big reg value for stack size");
assert( _locs_used[reg->value()] == OopMapValue::unused_value, "cannot insert twice" );
debug_only( _locs_used[reg->value()] = x; )
