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; )