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