public:
Base(BlockBegin* std_entry, BlockBegin* osr_entry) : BlockEnd(illegalType, NULL, false) {
assert(std_entry->is_set(BlockBegin::std_entry_flag), "std entry must be flagged");
assert(osr_entry == NULL || osr_entry->is_set(BlockBegin::osr_entry_flag), "osr entry must be flagged");
BlockList* s = new BlockList(2);
if (osr_entry != NULL) s->append(osr_entry);
s->append(std_entry); // must be default sux!
set_sux(s);
}
BlockBegin* std_entry() const { return default_sux(); }
BlockBegin* osr_entry() const { return number_of_sux() < 2 ? NULL : sux_at(0); }
};
LEAF(OsrEntry, Instruction)
public:
#ifdef _LP64
OsrEntry() : Instruction(longType) { pin(); }
#else
OsrEntry() : Instruction(intType) { pin(); }
#endif
virtual void input_values_do(ValueVisitor* f) { }
};
LEAF(ExceptionObject, Instruction)
public:
ExceptionObject() : Instruction(objectType) {
pin();
}
virtual void input_values_do(ValueVisitor* f) { }
};
LEAF(RoundFP, Instruction)
private:
Value _input; // floating-point value to be rounded
public:
RoundFP(Value input)
: Instruction(input->type()) // Note: should not be used for constants
, _input(input)
{
ASSERT_VALUES
}
Value input() const { return _input; }
virtual void input_values_do(ValueVisitor* f) { f->visit(&_input); }
};
BASE(UnsafeOp, Instruction)
private:
BasicType _basic_type; // ValueType can not express byte-sized integers
protected:
UnsafeOp(BasicType basic_type, bool is_put)
: Instruction(is_put ? voidType : as_ValueType(basic_type))
, _basic_type(basic_type)
{
pin();
}
public:
BasicType basic_type() { return _basic_type; }
virtual void input_values_do(ValueVisitor* f) { }
};
BASE(UnsafeRawOp, UnsafeOp)
private:
Value _base; // Base address (a Java long)
Value _index; // Index if computed by optimizer; initialized to NULL
int _log2_scale; // Scale factor: 0, 1, 2, or 3.
protected:
UnsafeRawOp(BasicType basic_type, Value addr, bool is_put)
: UnsafeOp(basic_type, is_put)
, _base(addr)
, _index(NULL)
, _log2_scale(0)
{
assert(addr != NULL && addr->type()->is_long(), "just checking");
}
UnsafeRawOp(BasicType basic_type, Value base, Value index, int log2_scale, bool is_put)
: UnsafeOp(basic_type, is_put)
, _base(base)
, _index(index)
, _log2_scale(log2_scale)
{
}
public:
Value base() { return _base; }
Value index() { return _index; }
bool has_index() { return (_index != NULL); }
int log2_scale() { return _log2_scale; }
void set_base (Value base) { _base = base; }
void set_index(Value index) { _index = index; }
void set_log2_scale(int log2_scale) { _log2_scale = log2_scale; }
virtual void input_values_do(ValueVisitor* f) { UnsafeOp::input_values_do(f);
f->visit(&_base);
if (has_index()) f->visit(&_index); }
};
LEAF(UnsafeGetRaw, UnsafeRawOp)
private:
bool _may_be_unaligned, _is_wide; // For OSREntry
public:
UnsafeGetRaw(BasicType basic_type, Value addr, bool may_be_unaligned, bool is_wide = false)
: UnsafeRawOp(basic_type, addr, false) {
_may_be_unaligned = may_be_unaligned;
_is_wide = is_wide;
}
UnsafeGetRaw(BasicType basic_type, Value base, Value index, int log2_scale, bool may_be_unaligned, bool is_wide = false)
: UnsafeRawOp(basic_type, base, index, log2_scale, false) {
_may_be_unaligned = may_be_unaligned;
_is_wide = is_wide;
}
bool may_be_unaligned() { return _may_be_unaligned; }
bool is_wide() { return _is_wide; }
};
LEAF(UnsafePutRaw, UnsafeRawOp)
private:
Value _value; // Value to be stored
public:
UnsafePutRaw(BasicType basic_type, Value addr, Value value)
: UnsafeRawOp(basic_type, addr, true)
, _value(value)
{
assert(value != NULL, "just checking");
ASSERT_VALUES
}
UnsafePutRaw(BasicType basic_type, Value base, Value index, int log2_scale, Value value)
: UnsafeRawOp(basic_type, base, index, log2_scale, true)
, _value(value)
{
assert(value != NULL, "just checking");
ASSERT_VALUES
}
Value value() { return _value; }
virtual void input_values_do(ValueVisitor* f) { UnsafeRawOp::input_values_do(f);
f->visit(&_value); }
};
BASE(UnsafeObjectOp, UnsafeOp)
private:
Value _object; // Object to be fetched from or mutated
Value _offset; // Offset within object
bool _is_volatile; // true if volatile - dl/JSR166
public:
UnsafeObjectOp(BasicType basic_type, Value object, Value offset, bool is_put, bool is_volatile)
: UnsafeOp(basic_type, is_put), _object(object), _offset(offset), _is_volatile(is_volatile)
{
}
Value object() { return _object; }
Value offset() { return _offset; }
bool is_volatile() { return _is_volatile; }
virtual void input_values_do(ValueVisitor* f) { UnsafeOp::input_values_do(f);
f->visit(&_object);
f->visit(&_offset); }
};
LEAF(UnsafeGetObject, UnsafeObjectOp)
public:
UnsafeGetObject(BasicType basic_type, Value object, Value offset, bool is_volatile)
: UnsafeObjectOp(basic_type, object, offset, false, is_volatile)
{
ASSERT_VALUES
}
};
LEAF(UnsafePutObject, UnsafeObjectOp)
private:
Value _value; // Value to be stored
public:
UnsafePutObject(BasicType basic_type, Value object, Value offset, Value value, bool is_volatile)
: UnsafeObjectOp(basic_type, object, offset, true, is_volatile)
, _value(value)
{
ASSERT_VALUES
}
Value value() { return _value; }
virtual void input_values_do(ValueVisitor* f) { UnsafeObjectOp::input_values_do(f);
f->visit(&_value); }
};
LEAF(UnsafeGetAndSetObject, UnsafeObjectOp)
private:
Value _value; // Value to be stored
bool _is_add;
public:
UnsafeGetAndSetObject(BasicType basic_type, Value object, Value offset, Value value, bool is_add)
: UnsafeObjectOp(basic_type, object, offset, false, false)
, _value(value)
, _is_add(is_add)
{
ASSERT_VALUES
}
bool is_add() const { return _is_add; }
Value value() { return _value; }
virtual void input_values_do(ValueVisitor* f) { UnsafeObjectOp::input_values_do(f);
f->visit(&_value); }
};
BASE(UnsafePrefetch, UnsafeObjectOp)
public:
UnsafePrefetch(Value object, Value offset)
: UnsafeObjectOp(T_VOID, object, offset, false, false)
{
}
};
LEAF(UnsafePrefetchRead, UnsafePrefetch)
public:
UnsafePrefetchRead(Value object, Value offset)
: UnsafePrefetch(object, offset)
{
ASSERT_VALUES
}
};
LEAF(UnsafePrefetchWrite, UnsafePrefetch)
public:
UnsafePrefetchWrite(Value object, Value offset)
: UnsafePrefetch(object, offset)
{
ASSERT_VALUES
}
};
LEAF(ProfileCall, Instruction)
private:
ciMethod* _method;
int _bci_of_invoke;
ciMethod* _callee; // the method that is called at the given bci
Value _recv;
ciKlass* _known_holder;
Values* _obj_args; // arguments for type profiling
ArgsNonNullState _nonnull_state; // Do we know whether some arguments are never null?
bool _inlined; // Are we profiling a call that is inlined
public:
ProfileCall(ciMethod* method, int bci, ciMethod* callee, Value recv, ciKlass* known_holder, Values* obj_args, bool inlined)
: Instruction(voidType)
, _method(method)
, _bci_of_invoke(bci)
, _callee(callee)
, _recv(recv)
, _known_holder(known_holder)
, _obj_args(obj_args)
, _inlined(inlined)
{
pin();
}
ciMethod* method() const { return _method; }
int bci_of_invoke() const { return _bci_of_invoke; }
ciMethod* callee() const { return _callee; }
Value recv() const { return _recv; }
ciKlass* known_holder() const { return _known_holder; }
int nb_profiled_args() const { return _obj_args == NULL ? 0 : _obj_args->length(); }
Value profiled_arg_at(int i) const { return _obj_args->at(i); }
bool arg_needs_null_check(int i) const {
return _nonnull_state.arg_needs_null_check(i);
}
bool inlined() const { return _inlined; }
void set_arg_needs_null_check(int i, bool check) {
_nonnull_state.set_arg_needs_null_check(i, check);
}
virtual void input_values_do(ValueVisitor* f) {
if (_recv != NULL) {
f->visit(&_recv);
}
for (int i = 0; i < nb_profiled_args(); i++) {
f->visit(_obj_args->adr_at(i));
}
}
};
LEAF(ProfileReturnType, Instruction)
private:
ciMethod* _method;
ciMethod* _callee;
int _bci_of_invoke;
Value _ret;
public:
ProfileReturnType(ciMethod* method, int bci, ciMethod* callee, Value ret)
: Instruction(voidType)
, _method(method)
, _callee(callee)
, _bci_of_invoke(bci)
, _ret(ret)
{
set_needs_null_check(true);
pin();
}
ciMethod* method() const { return _method; }
ciMethod* callee() const { return _callee; }
int bci_of_invoke() const { return _bci_of_invoke; }
Value ret() const { return _ret; }
virtual void input_values_do(ValueVisitor* f) {
if (_ret != NULL) {
f->visit(&_ret);
}
}
};
LEAF(RuntimeCall, Instruction)
private:
const char* _entry_name;
address _entry;
Values* _args;
bool _pass_thread; // Pass the JavaThread* as an implicit first argument
public:
RuntimeCall(ValueType* type, const char* entry_name, address entry, Values* args, bool pass_thread = true)
: Instruction(type)
, _entry(entry)
, _args(args)
, _entry_name(entry_name)
, _pass_thread(pass_thread) {
ASSERT_VALUES
pin();
}
const char* entry_name() const { return _entry_name; }
address entry() const { return _entry; }
int number_of_arguments() const { return _args->length(); }
Value argument_at(int i) const { return _args->at(i); }
bool pass_thread() const { return _pass_thread; }
virtual void input_values_do(ValueVisitor* f) {
for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
}
};
LEAF(ProfileInvoke, Instruction)
private:
ciMethod* _inlinee;
ValueStack* _state;
public:
ProfileInvoke(ciMethod* inlinee, ValueStack* state)
: Instruction(voidType)
, _inlinee(inlinee)
, _state(state)
{
pin();
}
ciMethod* inlinee() { return _inlinee; }
ValueStack* state() { return _state; }
virtual void input_values_do(ValueVisitor*) {}
virtual void state_values_do(ValueVisitor*);
};
LEAF(MemBar, Instruction)
private:
LIR_Code _code;
public:
MemBar(LIR_Code code)
: Instruction(voidType)
, _code(code)
{
pin();
}
LIR_Code code() { return _code; }
virtual void input_values_do(ValueVisitor*) {}
};
class BlockPair: public CompilationResourceObj {
private:
BlockBegin* _from;
BlockBegin* _to;
public:
BlockPair(BlockBegin* from, BlockBegin* to): _from(from), _to(to) {}
BlockBegin* from() const { return _from; }
BlockBegin* to() const { return _to; }
bool is_same(BlockBegin* from, BlockBegin* to) const { return _from == from && _to == to; }
bool is_same(BlockPair* p) const { return _from == p->from() && _to == p->to(); }
void set_to(BlockBegin* b) { _to = b; }
void set_from(BlockBegin* b) { _from = b; }
};
define_array(BlockPairArray, BlockPair*)
define_stack(BlockPairList, BlockPairArray)
inline int BlockBegin::number_of_sux() const { assert(_end == NULL || _end->number_of_sux() == _successors.length(), "mismatch"); return _successors.length(); }
inline BlockBegin* BlockBegin::sux_at(int i) const { assert(_end == NULL || _end->sux_at(i) == _successors.at(i), "mismatch"); return _successors.at(i); }
inline void BlockBegin::add_successor(BlockBegin* sux) { assert(_end == NULL, "Would create mismatch with successors of BlockEnd"); _successors.append(sux); }
#undef ASSERT_VALUES
#endif // SHARE_VM_C1_C1_INSTRUCTION_HPP
C:\hotspot-69087d08d473\src\share\vm/c1/c1_InstructionPrinter.cpp
#include "precompiled.hpp"
#include "c1/c1_InstructionPrinter.hpp"
#include "c1/c1_ValueStack.hpp"
#include "ci/ciArray.hpp"
#include "ci/ciInstance.hpp"
#include "ci/ciObject.hpp"
#ifndef PRODUCT
const char* InstructionPrinter::basic_type_name(BasicType type) {
switch (type) {
case T_BOOLEAN: return "boolean";
case T_BYTE : return "byte";
case T_CHAR : return "char";
case T_SHORT : return "short";
case T_INT : return "int";
case T_LONG : return "long";
case T_FLOAT : return "float";
case T_DOUBLE : return "double";
case T_ARRAY : return "array";
case T_OBJECT : return "object";
default : return "???";
}
}
const char* InstructionPrinter::cond_name(If::Condition cond) {
switch (cond) {
case If::eql: return "==";
case If::neq: return "!=";
case If::lss: return "<";
case If::leq: return "<=";
case If::gtr: return ">";
case If::geq: return ">=";
case If::aeq: return "|>=|";
case If::beq: return "|<=|";
}
ShouldNotReachHere();
return NULL;
}
const char* InstructionPrinter::op_name(Bytecodes::Code op) {
switch (op) {
case Bytecodes::_iadd : // fall through
case Bytecodes::_ladd : // fall through
case Bytecodes::_fadd : // fall through
case Bytecodes::_dadd : return "+";
case Bytecodes::_isub : // fall through
case Bytecodes::_lsub : // fall through
case Bytecodes::_fsub : // fall through
case Bytecodes::_dsub : return "-";
case Bytecodes::_imul : // fall through
case Bytecodes::_lmul : // fall through
case Bytecodes::_fmul : // fall through
case Bytecodes::_dmul : return "*";
case Bytecodes::_idiv : // fall through
case Bytecodes::_ldiv : // fall through
case Bytecodes::_fdiv : // fall through
case Bytecodes::_ddiv : return "/";
case Bytecodes::_irem : // fall through
case Bytecodes::_lrem : // fall through
case Bytecodes::_frem : // fall through
case Bytecodes::_drem : return "%";
case Bytecodes::_ishl : // fall through
case Bytecodes::_lshl : return "<<";
case Bytecodes::_ishr : // fall through
case Bytecodes::_lshr : return ">>";
case Bytecodes::_iushr: // fall through
case Bytecodes::_lushr: return ">>>";
case Bytecodes::_iand : // fall through
case Bytecodes::_land : return "&";
case Bytecodes::_ior : // fall through
case Bytecodes::_lor : return "|";
case Bytecodes::_ixor : // fall through
case Bytecodes::_lxor : return "^";
}
return Bytecodes::name(op);
}
bool InstructionPrinter::is_illegal_phi(Value v) {
Phi* phi = v ? v->as_Phi() : NULL;
if (phi && phi->is_illegal()) {
return true;
}
return false;
}
bool InstructionPrinter::is_phi_of_block(Value v, BlockBegin* b) {
Phi* phi = v ? v->as_Phi() : NULL;
return phi && phi->block() == b;
}
void InstructionPrinter::print_klass(ciKlass* klass) {
klass->name()->print_symbol_on(output());
}
void InstructionPrinter::print_object(Value obj) {
ValueType* type = obj->type();
if (type->as_ObjectConstant() != NULL) {
ciObject* value = type->as_ObjectConstant()->value();
if (value->is_null_object()) {
output()->print("null");
} else if (!value->is_loaded()) {
output()->print("<unloaded object " INTPTR_FORMAT ">", p2i(value));
} else {
output()->print("<object " INTPTR_FORMAT " klass=", p2i(value->constant_encoding()));
print_klass(value->klass());
output()->print(">");
}
} else if (type->as_InstanceConstant() != NULL) {
ciInstance* value = type->as_InstanceConstant()->value();
if (value->is_loaded()) {
output()->print("<instance " INTPTR_FORMAT " klass=", p2i(value->constant_encoding()));
print_klass(value->klass());
output()->print(">");
} else {
output()->print("<unloaded instance " INTPTR_FORMAT ">", p2i(value));
}
} else if (type->as_ArrayConstant() != NULL) {
output()->print("<array " INTPTR_FORMAT ">", p2i(type->as_ArrayConstant()->value()->constant_encoding()));
} else if (type->as_ClassConstant() != NULL) {
ciInstanceKlass* klass = type->as_ClassConstant()->value();
if (!klass->is_loaded()) {
output()->print("<unloaded> ");
}
output()->print("class ");
print_klass(klass);
} else if (type->as_MethodConstant() != NULL) {
ciMethod* m = type->as_MethodConstant()->value();
output()->print("<method %s.%s>", m->holder()->name()->as_utf8(), m->name()->as_utf8());
} else {
output()->print("???");
}
}
void InstructionPrinter::print_temp(Value value) {
output()->print("%c%d", value->type()->tchar(), value->id());
}
void InstructionPrinter::print_field(AccessField* field) {
print_value(field->obj());
output()->print("._%d", field->offset());
}
void InstructionPrinter::print_indexed(AccessIndexed* indexed) {
print_value(indexed->array());
output()->put('[');
print_value(indexed->index());
output()->put(']');
if (indexed->length() != NULL) {
output()->put('(');
print_value(indexed->length());
output()->put(')');
}
}
void InstructionPrinter::print_monitor(AccessMonitor* monitor) {
output()->print("monitor[%d](", monitor->monitor_no());
print_value(monitor->obj());
output()->put(')');
}
void InstructionPrinter::print_op2(Op2* instr) {
print_value(instr->x());
output()->print(" %s ", op_name(instr->op()));
print_value(instr->y());
}
void InstructionPrinter::print_value(Value value) {
if (value == NULL) {
output()->print("NULL");
} else {
print_temp(value);
}
}
void InstructionPrinter::print_instr(Instruction* instr) {
instr->visit(this);
}
void InstructionPrinter::print_stack(ValueStack* stack) {
int start_position = output()->position();
if (stack->stack_is_empty()) {
output()->print("empty stack");
} else {
output()->print("stack [");
for (int i = 0; i < stack->stack_size();) {
if (i > 0) output()->print(", ");
output()->print("%d:", i);
Value value = stack->stack_at_inc(i);
print_value(value);
Phi* phi = value->as_Phi();
if (phi != NULL) {
if (phi->operand()->is_valid()) {
output()->print(" ");
phi->operand()->print(output());
}
}
}
output()->put(']');
}
if (!stack->no_active_locks()) {
output()->cr();
fill_to(start_position, ' ');
output()->print("locks [");
for (int i = i = 0; i < stack->locks_size(); i++) {
Value t = stack->lock_at(i);
if (i > 0) output()->print(", ");
output()->print("%d:", i);
if (t == NULL) {
output()->print("this");
} else {
print_value(t);
}
}
output()->print("]");
}
}
void InstructionPrinter::print_inline_level(BlockBegin* block) {
output()->print_cr("inlining depth %d", block->scope()->level());
}
void InstructionPrinter::print_unsafe_op(UnsafeOp* op, const char* name) {
output()->print("%s", name);
output()->print(".(");
}
void InstructionPrinter::print_unsafe_raw_op(UnsafeRawOp* op, const char* name) {
print_unsafe_op(op, name);
output()->print("base ");
print_value(op->base());
if (op->has_index()) {
output()->print(", index "); print_value(op->index());
output()->print(", log2_scale %d", op->log2_scale());
}
}
void InstructionPrinter::print_unsafe_object_op(UnsafeObjectOp* op, const char* name) {
print_unsafe_op(op, name);
print_value(op->object());
output()->print(", ");
print_value(op->offset());
}
void InstructionPrinter::print_phi(int i, Value v, BlockBegin* b) {
Phi* phi = v->as_Phi();
output()->print("%2d ", i);
print_value(v);
if (phi && phi->block() == b) {
output()->print(" [");
for (int j = 0; j < phi->operand_count(); j ++) {
output()->print(" ");
Value opd = phi->operand_at(j);
if (opd) print_value(opd);
else output()->print("NULL");
}
output()->print("] ");
}
print_alias(v);
}
void InstructionPrinter::print_alias(Value v) {
if (v != v->subst()) {
output()->print("alias "); print_value(v->subst());
}
}
void InstructionPrinter::fill_to(int pos, char filler) {
while (output()->position() < pos) output()->put(filler);
}
void InstructionPrinter::print_head() {
const char filler = '_';
fill_to(bci_pos , filler); output()->print("bci" );
fill_to(use_pos , filler); output()->print("use" );
fill_to(temp_pos , filler); output()->print("tid" );
fill_to(instr_pos, filler); output()->print("instr");
fill_to(end_pos , filler);
output()->cr();
}
void InstructionPrinter::print_line(Instruction* instr) {
if (instr->is_pinned()) output()->put('.');
fill_to(bci_pos ); output()->print("%d", instr->printable_bci());
fill_to(use_pos ); output()->print("%d", instr->use_count());
fill_to(temp_pos ); print_temp(instr);
fill_to(instr_pos); print_instr(instr);
output()->cr();
StateSplit* split = instr->as_StateSplit();
if (split != NULL && split->state() != NULL && !split->state()->stack_is_empty()) {
fill_to(instr_pos); print_stack(split->state());
output()->cr();
}
}
void InstructionPrinter::do_Phi(Phi* x) {
output()->print("phi function"); // make that more detailed later
if (x->is_illegal())
output()->print(" (illegal)");
}
void InstructionPrinter::do_Local(Local* x) {
output()->print("local[index %d]", x->java_index());
}
void InstructionPrinter::do_Constant(Constant* x) {
ValueType* t = x->type();
switch (t->tag()) {
case intTag : output()->print("%d" , t->as_IntConstant ()->value()); break;
case longTag : output()->print(JLONG_FORMAT, t->as_LongConstant()->value()); output()->print("L"); break;
case floatTag : output()->print("%g" , t->as_FloatConstant ()->value()); break;
case doubleTag : output()->print("%gD" , t->as_DoubleConstant()->value()); break;
case objectTag : print_object(x); break;
case addressTag: output()->print("bci:%d", t->as_AddressConstant()->value()); break;
default : output()->print("???"); break;
}
}
void InstructionPrinter::do_LoadField(LoadField* x) {
print_field(x);
output()->print(" (%c)", type2char(x->field()->type()->basic_type()));
output()->print(" %s", x->field()->name()->as_utf8());
}
void InstructionPrinter::do_StoreField(StoreField* x) {
print_field(x);
output()->print(" := ");
print_value(x->value());
output()->print(" (%c)", type2char(x->field()->type()->basic_type()));
output()->print(" %s", x->field()->name()->as_utf8());
}
void InstructionPrinter::do_ArrayLength(ArrayLength* x) {
print_value(x->array());
output()->print(".length");
}
void InstructionPrinter::do_LoadIndexed(LoadIndexed* x) {
print_indexed(x);
output()->print(" (%c)", type2char(x->elt_type()));
if (x->check_flag(Instruction::NeedsRangeCheckFlag)) {
output()->print(" [rc]");
}
}
void InstructionPrinter::do_StoreIndexed(StoreIndexed* x) {
print_indexed(x);
output()->print(" := ");
print_value(x->value());
output()->print(" (%c)", type2char(x->elt_type()));
if (x->check_flag(Instruction::NeedsRangeCheckFlag)) {
output()->print(" [rc]");
}
}
void InstructionPrinter::do_NegateOp(NegateOp* x) {
output()->put('-');
print_value(x->x());
}
void InstructionPrinter::do_ArithmeticOp(ArithmeticOp* x) {
print_op2(x);
}
void InstructionPrinter::do_ShiftOp(ShiftOp* x) {
print_op2(x);
}
void InstructionPrinter::do_LogicOp(LogicOp* x) {
print_op2(x);
}
void InstructionPrinter::do_CompareOp(CompareOp* x) {
print_op2(x);
}
void InstructionPrinter::do_IfOp(IfOp* x) {
print_value(x->x());
output()->print(" %s ", cond_name(x->cond()));
print_value(x->y());
output()->print(" ? ");
print_value(x->tval());
output()->print(" : ");
print_value(x->fval());
}
void InstructionPrinter::do_Convert(Convert* x) {
output()->print("%s(", Bytecodes::name(x->op()));
print_value(x->value());
output()->put(')');
}
void InstructionPrinter::do_NullCheck(NullCheck* x) {
output()->print("null_check(");
print_value(x->obj());
output()->put(')');
if (!x->can_trap()) {
output()->print(" (eliminated)");
}
}
void InstructionPrinter::do_TypeCast(TypeCast* x) {
output()->print("type_cast(");
print_value(x->obj());
output()->print(") ");
if (x->declared_type()->is_klass())
print_klass(x->declared_type()->as_klass());
else
output()->print("%s", type2name(x->declared_type()->basic_type()));
}
void InstructionPrinter::do_Invoke(Invoke* x) {
if (x->receiver() != NULL) {
print_value(x->receiver());
output()->print(".");
}
output()->print("%s(", Bytecodes::name(x->code()));
for (int i = 0; i < x->number_of_arguments(); i++) {
if (i > 0) output()->print(", ");
print_value(x->argument_at(i));
}
output()->print_cr(")");
fill_to(instr_pos);
output()->print("%s.%s%s",
x->target()->holder()->name()->as_utf8(),
x->target()->name()->as_utf8(),
x->target()->signature()->as_symbol()->as_utf8());
}
void InstructionPrinter::do_NewInstance(NewInstance* x) {
output()->print("new instance ");
print_klass(x->klass());
}
void InstructionPrinter::do_NewTypeArray(NewTypeArray* x) {
output()->print("new %s array [", basic_type_name(x->elt_type()));
print_value(x->length());
output()->put(']');
}
void InstructionPrinter::do_NewObjectArray(NewObjectArray* x) {
output()->print("new object array [");
print_value(x->length());
output()->print("] ");
print_klass(x->klass());
}
void InstructionPrinter::do_NewMultiArray(NewMultiArray* x) {
output()->print("new multi array [");
Values* dims = x->dims();
for (int i = 0; i < dims->length(); i++) {
if (i > 0) output()->print(", ");
print_value(dims->at(i));
}
output()->print("] ");
print_klass(x->klass());
}
void InstructionPrinter::do_MonitorEnter(MonitorEnter* x) {
output()->print("enter ");
print_monitor(x);
}
void InstructionPrinter::do_MonitorExit(MonitorExit* x) {
output()->print("exit ");
print_monitor(x);
}
void InstructionPrinter::do_Intrinsic(Intrinsic* x) {
const char* name = vmIntrinsics::name_at(x->id());
if (name[0] == '_') name++; // strip leading bug from _hashCode, etc.
const char* kname = vmSymbols::name_for(vmIntrinsics::class_for(x->id()));
if (strchr(name, '_') == NULL) {
kname = NULL;
} else {
const char* kptr = strrchr(kname, '/');
if (kptr != NULL) kname = kptr + 1;
}
if (kname == NULL)
output()->print("%s(", name);
else
output()->print("%s.%s(", kname, name);
for (int i = 0; i < x->number_of_arguments(); i++) {
if (i > 0) output()->print(", ");
print_value(x->argument_at(i));
}
output()->put(')');
}
void InstructionPrinter::do_BlockBegin(BlockBegin* x) {
BlockEnd* end = x->end();
output()->print("B%d ", x->block_id());
bool printed_flag = false;
if (x->is_set(BlockBegin::std_entry_flag)) {
if (!printed_flag) output()->print("(");
output()->print("S"); printed_flag = true;
}
if (x->is_set(BlockBegin::osr_entry_flag)) {
if (!printed_flag) output()->print("(");
output()->print("O"); printed_flag = true;
}
if (x->is_set(BlockBegin::exception_entry_flag)) {
if (!printed_flag) output()->print("(");
output()->print("E"); printed_flag = true;
}
if (x->is_set(BlockBegin::subroutine_entry_flag)) {
if (!printed_flag) output()->print("(");
output()->print("s"); printed_flag = true;
}
if (x->is_set(BlockBegin::parser_loop_header_flag)) {
if (!printed_flag) output()->print("(");
output()->print("LH"); printed_flag = true;
}
if (x->is_set(BlockBegin::backward_branch_target_flag)) {
if (!printed_flag) output()->print("(");
output()->print("b"); printed_flag = true;
}
if (x->is_set(BlockBegin::was_visited_flag)) {
if (!printed_flag) output()->print("(");
output()->print("V"); printed_flag = true;
}
if (printed_flag) output()->print(") ");
output()->print("[%d, %d]", x->bci(), (end == NULL ? -1 : end->printable_bci()));
if (end != NULL && end->number_of_sux() > 0) {
output()->print(" ->");
for (int i = 0; i < end->number_of_sux(); i++) {
output()->print(" B%d", end->sux_at(i)->block_id());
}
}
if (x->number_of_exception_handlers() > 0) {
output()->print(" (xhandlers ");
for (int i = 0; i < x->number_of_exception_handlers(); i++) {
if (i > 0) output()->print(" ");
output()->print("B%d", x->exception_handler_at(i)->block_id());
}
output()->put(')');
}
if (x->dominator() != NULL) {
output()->print(" dom B%d", x->dominator()->block_id());
}
if (x->successors()->length() > 0) {
output()->print(" sux:");
for (int i = 0; i < x->successors()->length(); i ++) {
output()->print(" B%d", x->successors()->at(i)->block_id());
}
}
if (x->number_of_preds() > 0) {
output()->print(" pred:");
for (int i = 0; i < x->number_of_preds(); i ++) {
output()->print(" B%d", x->pred_at(i)->block_id());
}
}
if (!_print_phis) {
return;
}
bool has_phis_in_locals = false;
bool has_phis_on_stack = false;
if (x->end() && x->end()->state()) {
ValueStack* state = x->state();
int i = 0;
while (!has_phis_on_stack && i < state->stack_size()) {
Value v = state->stack_at_inc(i);
has_phis_on_stack = is_phi_of_block(v, x);
}
do {
for (i = 0; !has_phis_in_locals && i < state->locals_size();) {
Value v = state->local_at(i);
has_phis_in_locals = is_phi_of_block(v, x);
if (v && !v->type()->is_illegal()) i += v->type()->size(); else i ++;
}
state = state->caller_state();
} while (state != NULL);
}
if (has_phis_in_locals) {
output()->cr(); output()->print_cr("Locals:");
ValueStack* state = x->state();
do {
for (int i = 0; i < state->locals_size();) {
Value v = state->local_at(i);
if (v) {
print_phi(i, v, x); output()->cr();
i += (v->type()->is_illegal() ? 1 : v->type()->size());
} else {
i ++;
}
}
output()->cr();
state = state->caller_state();
} while (state != NULL);
}
if (has_phis_on_stack) {
output()->print_cr("Stack:");
int i = 0;
while (i < x->state()->stack_size()) {
int o = i;
Value v = x->state()->stack_at_inc(i);
if (v) {
print_phi(o, v, x); output()->cr();
}
}
}
}
void InstructionPrinter::do_CheckCast(CheckCast* x) {
output()->print("checkcast(");
print_value(x->obj());
output()->print(") ");
print_klass(x->klass());
}
void InstructionPrinter::do_InstanceOf(InstanceOf* x) {
output()->print("instanceof(");
print_value(x->obj());
output()->print(") ");
print_klass(x->klass());
}
void InstructionPrinter::do_Goto(Goto* x) {
output()->print("goto B%d", x->default_sux()->block_id());
if (x->is_safepoint()) output()->print(" (safepoint)");
}
void InstructionPrinter::do_If(If* x) {
output()->print("if ");
print_value(x->x());
output()->print(" %s ", cond_name(x->cond()));
print_value(x->y());
output()->print(" then B%d else B%d", x->sux_at(0)->block_id(), x->sux_at(1)->block_id());
if (x->is_safepoint()) output()->print(" (safepoint)");
}
void InstructionPrinter::do_IfInstanceOf(IfInstanceOf* x) {
output()->print("<IfInstanceOf>");
}
void InstructionPrinter::do_TableSwitch(TableSwitch* x) {
output()->print("tableswitch ");
if (x->is_safepoint()) output()->print("(safepoint) ");
print_value(x->tag());
output()->cr();
int l = x->length();
for (int i = 0; i < l; i++) {
fill_to(instr_pos);
output()->print_cr("case %5d: B%d", x->lo_key() + i, x->sux_at(i)->block_id());
}
fill_to(instr_pos);
output()->print("default : B%d", x->default_sux()->block_id());
}
void InstructionPrinter::do_LookupSwitch(LookupSwitch* x) {
output()->print("lookupswitch ");
if (x->is_safepoint()) output()->print("(safepoint) ");
print_value(x->tag());
output()->cr();
int l = x->length();
for (int i = 0; i < l; i++) {
fill_to(instr_pos);
output()->print_cr("case %5d: B%d", x->key_at(i), x->sux_at(i)->block_id());
}
fill_to(instr_pos);
output()->print("default : B%d", x->default_sux()->block_id());
}
void InstructionPrinter::do_Return(Return* x) {
if (x->result() == NULL) {
output()->print("return");
} else {
output()->print("%creturn ", x->type()->tchar());
print_value(x->result());
}
}
void InstructionPrinter::do_Throw(Throw* x) {
output()->print("throw ");
print_value(x->exception());
}
void InstructionPrinter::do_Base(Base* x) {
output()->print("std entry B%d", x->std_entry()->block_id());
if (x->number_of_sux() > 1) {
output()->print(" osr entry B%d", x->osr_entry()->block_id());
}
}
void InstructionPrinter::do_OsrEntry(OsrEntry* x) {
output()->print("osr entry");
}
void InstructionPrinter::do_ExceptionObject(ExceptionObject* x) {
output()->print("incoming exception");
}
void InstructionPrinter::do_RoundFP(RoundFP* x) {
output()->print("round_fp ");
print_value(x->input());
}
void InstructionPrinter::do_UnsafeGetRaw(UnsafeGetRaw* x) {
print_unsafe_raw_op(x, "UnsafeGetRaw");
output()->put(')');
}
void InstructionPrinter::do_UnsafePutRaw(UnsafePutRaw* x) {
print_unsafe_raw_op(x, "UnsafePutRaw");
output()->print(", value ");
print_value(x->value());
output()->put(')');
}
void InstructionPrinter::do_UnsafeGetObject(UnsafeGetObject* x) {
print_unsafe_object_op(x, "UnsafeGetObject");
output()->put(')');
}
void InstructionPrinter::do_UnsafePutObject(UnsafePutObject* x) {
print_unsafe_object_op(x, "UnsafePutObject");
output()->print(", value ");
print_value(x->value());
output()->put(')');
}
void InstructionPrinter::do_UnsafeGetAndSetObject(UnsafeGetAndSetObject* x) {
print_unsafe_object_op(x, x->is_add()?"UnsafeGetAndSetObject (add)":"UnsafeGetAndSetObject");
output()->print(", value ");
print_value(x->value());
output()->put(')');
}
void InstructionPrinter::do_UnsafePrefetchRead(UnsafePrefetchRead* x) {
print_unsafe_object_op(x, "UnsafePrefetchRead");
output()->put(')');
}
void InstructionPrinter::do_RangeCheckPredicate(RangeCheckPredicate* x) {
if (x->x() != NULL && x->y() != NULL) {
output()->print("if ");
print_value(x->x());
output()->print(" %s ", cond_name(x->cond()));
print_value(x->y());
output()->print(" then deoptimize!");
} else {
output()->print("always deoptimize!");
}
}
#ifdef ASSERT
void InstructionPrinter::do_Assert(Assert* x) {
output()->print("assert ");
print_value(x->x());
output()->print(" %s ", cond_name(x->cond()));
print_value(x->y());
}
#endif
void InstructionPrinter::do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) {
print_unsafe_object_op(x, "UnsafePrefetchWrite");
output()->put(')');
}
void InstructionPrinter::do_ProfileCall(ProfileCall* x) {
output()->print("profile ");
print_value(x->recv());
output()->print(" %s.%s", x->method()->holder()->name()->as_utf8(), x->method()->name()->as_utf8());
if (x->known_holder() != NULL) {
output()->print(", ");
print_klass(x->known_holder());
output()->print(" ");
}
for (int i = 0; i < x->nb_profiled_args(); i++) {
if (i > 0) output()->print(", ");
print_value(x->profiled_arg_at(i));
if (x->arg_needs_null_check(i)) {
output()->print(" [NC]");
}
}
output()->put(')');
}
void InstructionPrinter::do_ProfileReturnType(ProfileReturnType* x) {
output()->print("profile ret type ");
print_value(x->ret());
output()->print(" %s.%s", x->method()->holder()->name()->as_utf8(), x->method()->name()->as_utf8());
output()->put(')');
}
void InstructionPrinter::do_ProfileInvoke(ProfileInvoke* x) {
output()->print("profile_invoke ");
output()->print(" %s.%s", x->inlinee()->holder()->name()->as_utf8(), x->inlinee()->name()->as_utf8());
output()->put(')');
}
void InstructionPrinter::do_RuntimeCall(RuntimeCall* x) {
output()->print("call_rt %s(", x->entry_name());
for (int i = 0; i < x->number_of_arguments(); i++) {
if (i > 0) output()->print(", ");
print_value(x->argument_at(i));
}
output()->put(')');
}
void InstructionPrinter::do_MemBar(MemBar* x) {
if (os::is_MP()) {
LIR_Code code = x->code();
switch (code) {
case lir_membar_acquire : output()->print("membar_acquire"); break;
case lir_membar_release : output()->print("membar_release"); break;
case lir_membar : output()->print("membar"); break;
case lir_membar_loadload : output()->print("membar_loadload"); break;
case lir_membar_storestore: output()->print("membar_storestore"); break;
case lir_membar_loadstore : output()->print("membar_loadstore"); break;
case lir_membar_storeload : output()->print("membar_storeload"); break;
default : ShouldNotReachHere(); break;
}
}
}
#endif // PRODUCT
C:\hotspot-69087d08d473\src\share\vm/c1/c1_InstructionPrinter.hpp
#ifndef SHARE_VM_C1_C1_INSTRUCTIONPRINTER_HPP
#define SHARE_VM_C1_C1_INSTRUCTIONPRINTER_HPP
#include "c1/c1_IR.hpp"
#include "c1/c1_Instruction.hpp"
#include "c1/c1_Runtime1.hpp"
#ifndef PRODUCT
class InstructionPrinter: public InstructionVisitor {
private:
outputStream* _output;
bool _print_phis;
enum LayoutConstants {
bci_pos = 2,
use_pos = 7,
temp_pos = 12,
instr_pos = 19,
end_pos = 60
};
bool is_illegal_phi(Value v);
public:
InstructionPrinter(bool print_phis = true, outputStream* output = tty)
: _print_phis(print_phis)
, _output(output)
{}
outputStream* output() { return _output; }
static const char* basic_type_name(BasicType type);
static const char* cond_name(If::Condition cond);
static const char* op_name(Bytecodes::Code op);
bool is_phi_of_block(Value v, BlockBegin* b);
void print_klass(ciKlass* klass);
void print_object(Value obj);
void print_temp(Value value);
void print_field(AccessField* field);
void print_indexed(AccessIndexed* indexed);
void print_monitor(AccessMonitor* monitor);
void print_op2(Op2* instr);
void print_value(Value value);
void print_instr(Instruction* instr);
void print_stack(ValueStack* stack);
void print_inline_level(BlockBegin* block);
void print_unsafe_op(UnsafeOp* op, const char* name);
void print_unsafe_raw_op(UnsafeRawOp* op, const char* name);
void print_unsafe_object_op(UnsafeObjectOp* op, const char* name);
void print_phi(int i, Value v, BlockBegin* b);
void print_alias(Value v);
void fill_to(int pos, char filler = ' ');
void print_head();
void print_line(Instruction* instr);
virtual void do_Phi (Phi* x);
virtual void do_Local (Local* x);
virtual void do_Constant (Constant* x);
virtual void do_LoadField (LoadField* x);
virtual void do_StoreField (StoreField* x);
virtual void do_ArrayLength (ArrayLength* x);
virtual void do_LoadIndexed (LoadIndexed* x);
virtual void do_StoreIndexed (StoreIndexed* x);
virtual void do_NegateOp (NegateOp* x);
virtual void do_ArithmeticOp (ArithmeticOp* x);
virtual void do_ShiftOp (ShiftOp* x);
virtual void do_LogicOp (LogicOp* x);
virtual void do_CompareOp (CompareOp* x);
virtual void do_IfOp (IfOp* x);
virtual void do_Convert (Convert* x);
virtual void do_NullCheck (NullCheck* x);
virtual void do_TypeCast (TypeCast* x);
virtual void do_Invoke (Invoke* x);
virtual void do_NewInstance (NewInstance* x);
virtual void do_NewTypeArray (NewTypeArray* x);
virtual void do_NewObjectArray (NewObjectArray* x);
virtual void do_NewMultiArray (NewMultiArray* x);
virtual void do_CheckCast (CheckCast* x);
virtual void do_InstanceOf (InstanceOf* x);
virtual void do_MonitorEnter (MonitorEnter* x);
virtual void do_MonitorExit (MonitorExit* x);
virtual void do_Intrinsic (Intrinsic* x);
virtual void do_BlockBegin (BlockBegin* x);
virtual void do_Goto (Goto* x);
virtual void do_If (If* x);
virtual void do_IfInstanceOf (IfInstanceOf* x);
virtual void do_TableSwitch (TableSwitch* x);
virtual void do_LookupSwitch (LookupSwitch* x);
virtual void do_Return (Return* x);
virtual void do_Throw (Throw* x);
virtual void do_Base (Base* x);
virtual void do_OsrEntry (OsrEntry* x);
virtual void do_ExceptionObject(ExceptionObject* x);
virtual void do_RoundFP (RoundFP* x);
virtual void do_UnsafeGetRaw (UnsafeGetRaw* x);
virtual void do_UnsafePutRaw (UnsafePutRaw* x);
virtual void do_UnsafeGetObject(UnsafeGetObject* x);
virtual void do_UnsafePutObject(UnsafePutObject* x);
virtual void do_UnsafeGetAndSetObject(UnsafeGetAndSetObject* x);
virtual void do_UnsafePrefetchRead (UnsafePrefetchRead* x);
virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x);
virtual void do_ProfileCall (ProfileCall* x);
virtual void do_ProfileReturnType (ProfileReturnType* x);
virtual void do_ProfileInvoke (ProfileInvoke* x);
virtual void do_RuntimeCall (RuntimeCall* x);
virtual void do_MemBar (MemBar* x);
virtual void do_RangeCheckPredicate(RangeCheckPredicate* x);
#ifdef ASSERT
virtual void do_Assert (Assert* x);
#endif
};
#endif // PRODUCT
#endif // SHARE_VM_C1_C1_INSTRUCTIONPRINTER_HPP
C:\hotspot-69087d08d473\src\share\vm/c1/c1_IR.cpp
#include "precompiled.hpp"
#include "c1/c1_Compilation.hpp"
#include "c1/c1_FrameMap.hpp"
#include "c1/c1_GraphBuilder.hpp"
#include "c1/c1_IR.hpp"
#include "c1/c1_InstructionPrinter.hpp"
#include "c1/c1_Optimizer.hpp"
#include "utilities/bitMap.inline.hpp"
XHandlers::XHandlers(ciMethod* method) : _list(method->exception_table_length()) {
ciExceptionHandlerStream s(method);
while (!s.is_done()) {
_list.append(new XHandler(s.handler()));
s.next();
}
assert(s.count() == method->exception_table_length(), "exception table lengths inconsistent");
}
XHandlers::XHandlers(XHandlers* other) :
_list(other->length())
{
for (int i = 0; i < other->length(); i++) {
_list.append(new XHandler(other->handler_at(i)));
}
}
bool XHandlers::could_catch(ciInstanceKlass* klass, bool type_is_exact) const {
if (!klass->is_loaded()) {
return true;
}
for (int i = 0; i < length(); i++) {
XHandler* handler = handler_at(i);
if (handler->is_catch_all()) {
return true;
}
ciInstanceKlass* handler_klass = handler->catch_klass();
if (!handler_klass->is_loaded()) {
return true;
}
if (klass->is_subtype_of(handler_klass)) {
return true;
}
if (!type_is_exact) {
if (handler_klass->is_subtype_of(klass)) {
return true;
}
}
}
return false;
}
bool XHandlers::equals(XHandlers* others) const {
if (others == NULL) return false;
if (length() != others->length()) return false;
for (int i = 0; i < length(); i++) {
if (!handler_at(i)->equals(others->handler_at(i))) return false;
}
return true;
}
bool XHandler::equals(XHandler* other) const {
assert(entry_pco() != -1 && other->entry_pco() != -1, "must have entry_pco");
if (entry_pco() != other->entry_pco()) return false;
if (scope_count() != other->scope_count()) return false;
if (_desc != other->_desc) return false;
assert(entry_block() == other->entry_block(), "entry_block must be equal when entry_pco is equal");
return true;
}
BlockBegin* IRScope::build_graph(Compilation* compilation, int osr_bci) {
GraphBuilder gm(compilation, this);
NOT_PRODUCT(if (PrintValueNumbering && Verbose) gm.print_stats());
if (compilation->bailed_out()) return NULL;
return gm.start();
}
IRScope::IRScope(Compilation* compilation, IRScope* caller, int caller_bci, ciMethod* method, int osr_bci, bool create_graph)
: _callees(2)
, _compilation(compilation)
, _requires_phi_function(method->max_locals())
{
_caller = caller;
_level = caller == NULL ? 0 : caller->level() + 1;
_method = method;
_xhandlers = new XHandlers(method);
_number_of_locks = 0;
_monitor_pairing_ok = method->has_balanced_monitors();
_wrote_final = false;
_start = NULL;
if (osr_bci == -1) {
_requires_phi_function.clear();
} else {
_requires_phi_function.set_range(0, method->max_locals());
}
assert(method->holder()->is_loaded() , "method holder must be loaded");
if (create_graph && monitor_pairing_ok()) _start = build_graph(compilation, osr_bci);
}
int IRScope::max_stack() const {
int my_max = method()->max_stack();
int callee_max = 0;
for (int i = 0; i < number_of_callees(); i++) {
callee_max = MAX2(callee_max, callee_no(i)->max_stack());
}
return my_max + callee_max;
}
bool IRScopeDebugInfo::should_reexecute() {
ciMethod* cur_method = scope()->method();
int cur_bci = bci();
if (cur_method != NULL && cur_bci != SynchronizationEntryBCI) {
Bytecodes::Code code = cur_method->java_code_at_bci(cur_bci);
return Interpreter::bytecode_should_reexecute(code);
} else
return false;
}
CodeEmitInfo::CodeEmitInfo(ValueStack* stack, XHandlers* exception_handlers, bool deoptimize_on_exception)
: _scope(stack->scope())
, _scope_debug_info(NULL)
, _oop_map(NULL)
, _stack(stack)
, _exception_handlers(exception_handlers)
, _is_method_handle_invoke(false)
, _deoptimize_on_exception(deoptimize_on_exception) {
assert(_stack != NULL, "must be non null");
}
CodeEmitInfo::CodeEmitInfo(CodeEmitInfo* info, ValueStack* stack)
: _scope(info->_scope)
, _exception_handlers(NULL)
, _scope_debug_info(NULL)
, _oop_map(NULL)
, _stack(stack == NULL ? info->_stack : stack)
, _is_method_handle_invoke(info->_is_method_handle_invoke)
, _deoptimize_on_exception(info->_deoptimize_on_exception) {
if (info->_exception_handlers != NULL) {
_exception_handlers = new XHandlers(info->_exception_handlers);
}
}
void CodeEmitInfo::record_debug_info(DebugInformationRecorder* recorder, int pc_offset) {
recorder->add_safepoint(pc_offset, _oop_map->deep_copy());
_scope_debug_info->record_debug_info(recorder, pc_offset, true/*topmost*/, _is_method_handle_invoke);
recorder->end_safepoint(pc_offset);
}
void CodeEmitInfo::add_register_oop(LIR_Opr opr) {
assert(_oop_map != NULL, "oop map must already exist");
assert(opr->is_single_cpu(), "should not call otherwise");
VMReg name = frame_map()->regname(opr);
_oop_map->set_oop(name);
}
int CodeEmitInfo::interpreter_frame_size() const {
ValueStack* state = _stack;
int size = 0;
int callee_parameters = 0;
int callee_locals = 0;
int extra_args = state->scope()->method()->max_stack() - state->stack_size();
while (state != NULL) {
int locks = state->locks_size();
int temps = state->stack_size();
bool is_top_frame = (state == _stack);
ciMethod* method = state->scope()->method();
int frame_size = BytesPerWord * Interpreter::size_activation(method->max_stack(),
temps + callee_parameters,
extra_args,
locks,
callee_parameters,
callee_locals,
is_top_frame);
size += frame_size;
callee_parameters = method->size_of_parameters();
callee_locals = method->max_locals();
extra_args = 0;
state = state->caller_state();
}
return size + Deoptimization::last_frame_adjust(0, callee_locals) * BytesPerWord;
}
IR::IR(Compilation* compilation, ciMethod* method, int osr_bci) :
_locals_size(in_WordSize(-1))
, _num_loops(0) {
_compilation = compilation;
_top_scope = new IRScope(compilation, NULL, -1, method, osr_bci, true);
_code = NULL;
}
void IR::optimize_blocks() {
Optimizer opt(this);
if (!compilation()->profile_branches()) {
if (DoCEE) {
opt.eliminate_conditional_expressions();
#ifndef PRODUCT
if (PrintCFG || PrintCFG1) { tty->print_cr("CFG after CEE"); print(true); }
if (PrintIR || PrintIR1 ) { tty->print_cr("IR after CEE"); print(false); }
#endif
}
if (EliminateBlocks) {
opt.eliminate_blocks();
#ifndef PRODUCT
if (PrintCFG || PrintCFG1) { tty->print_cr("CFG after block elimination"); print(true); }
if (PrintIR || PrintIR1 ) { tty->print_cr("IR after block elimination"); print(false); }
#endif
}
}
}
void IR::eliminate_null_checks() {
Optimizer opt(this);
if (EliminateNullChecks) {
opt.eliminate_null_checks();
#ifndef PRODUCT
if (PrintCFG || PrintCFG1) { tty->print_cr("CFG after null check elimination"); print(true); }
if (PrintIR || PrintIR1 ) { tty->print_cr("IR after null check elimination"); print(false); }
#endif
}
}
static int sort_pairs(BlockPair** a, BlockPair** b) {
if ((*a)->from() == (*b)->from()) {
return (*a)->to()->block_id() - (*b)->to()->block_id();
} else {
return (*a)->from()->block_id() - (*b)->from()->block_id();
}
}
class CriticalEdgeFinder: public BlockClosure {
BlockPairList blocks;
IR* _ir;
public:
CriticalEdgeFinder(IR* ir): _ir(ir) {}
void block_do(BlockBegin* bb) {
BlockEnd* be = bb->end();
int nos = be->number_of_sux();
if (nos >= 2) {
for (int i = 0; i < nos; i++) {
BlockBegin* sux = be->sux_at(i);
if (sux->number_of_preds() >= 2) {
blocks.append(new BlockPair(bb, sux));
}
}
}
}
void split_edges() {
BlockPair* last_pair = NULL;
blocks.sort(sort_pairs);
for (int i = 0; i < blocks.length(); i++) {
BlockPair* pair = blocks.at(i);
if (last_pair != NULL && pair->is_same(last_pair)) continue;
BlockBegin* from = pair->from();
BlockBegin* to = pair->to();
BlockBegin* split = from->insert_block_between(to);
#ifndef PRODUCT
if ((PrintIR || PrintIR1) && Verbose) {
tty->print_cr("Split critical edge B%d -> B%d (new block B%d)",
from->block_id(), to->block_id(), split->block_id());
}
#endif
last_pair = pair;
}
}
};
void IR::split_critical_edges() {
CriticalEdgeFinder cef(this);
iterate_preorder(&cef);
cef.split_edges();
}
class UseCountComputer: public ValueVisitor, BlockClosure {
private:
void visit(Value* n) {
if (!(*n)->is_linked() && (*n)->can_be_linked()) {
assert(false, "a node was not appended to the graph");
Compilation::current()->bailout("a node was not appended to the graph");
}
if (!(*n)->is_pinned() && !(*n)->has_uses()) {
uses_do(n);
}
(*n)->_use_count++;
}
Values* worklist;
int depth;
enum {
max_recurse_depth = 20
};
void uses_do(Value* n) {
depth++;
if (depth > max_recurse_depth) {
worklist->push(*n);
} else {
(*n)->input_values_do(this);
if ((*n)->as_BlockEnd() != NULL) {
(*n)->state_values_do(this);
}
}
depth--;
}
void block_do(BlockBegin* b) {
depth = 0;
for (Instruction* n = b; n != NULL; n = n->next()) {
if (n->is_pinned()) uses_do(&n);
}
assert(depth == 0, "should have counted back down");
while (worklist->length() > 0) {
Value t = worklist->pop();
if (!t->is_pinned()) {
uses_do(&t);
t->pin();
}
}
assert(depth == 0, "should have counted back down");
}
UseCountComputer() {
worklist = new Values();
depth = 0;
}
public:
static void compute(BlockList* blocks) {
UseCountComputer ucc;
blocks->iterate_backward(&ucc);
}
};
#ifndef PRODUCT
#define TRACE_LINEAR_SCAN(level, code) \
if (TraceLinearScanLevel >= level) { \
code; \
}
#else
#define TRACE_LINEAR_SCAN(level, code)
#endif
class ComputeLinearScanOrder : public StackObj {
private:
int _max_block_id; // the highest block_id of a block
int _num_blocks; // total number of blocks (smaller than _max_block_id)
int _num_loops; // total number of loops
bool _iterative_dominators;// method requires iterative computation of dominatiors
BlockList* _linear_scan_order; // the resulting list of blocks in correct order
BitMap _visited_blocks; // used for recursive processing of blocks
BitMap _active_blocks; // used for recursive processing of blocks
BitMap _dominator_blocks; // temproary BitMap used for computation of dominator
intArray _forward_branches; // number of incoming forward branches for each block
BlockList _loop_end_blocks; // list of all loop end blocks collected during count_edges
BitMap2D _loop_map; // two-dimensional bit set: a bit is set if a block is contained in a loop
BlockList _work_list; // temporary list (used in mark_loops and compute_order)
BlockList _loop_headers;
Compilation* _compilation;
void init_visited() { _active_blocks.clear(); _visited_blocks.clear(); }
bool is_visited(BlockBegin* b) const { return _visited_blocks.at(b->block_id()); }
bool is_active(BlockBegin* b) const { return _active_blocks.at(b->block_id()); }
void set_visited(BlockBegin* b) { assert(!is_visited(b), "already set"); _visited_blocks.set_bit(b->block_id()); }
void set_active(BlockBegin* b) { assert(!is_active(b), "already set"); _active_blocks.set_bit(b->block_id()); }
void clear_active(BlockBegin* b) { assert(is_active(b), "not already"); _active_blocks.clear_bit(b->block_id()); }
void inc_forward_branches(BlockBegin* b) { _forward_branches.at_put(b->block_id(), _forward_branches.at(b->block_id()) + 1); }
int dec_forward_branches(BlockBegin* b) { _forward_branches.at_put(b->block_id(), _forward_branches.at(b->block_id()) - 1); return _forward_branches.at(b->block_id()); }
bool is_block_in_loop (int loop_idx, BlockBegin* b) const { return _loop_map.at(loop_idx, b->block_id()); }
void set_block_in_loop (int loop_idx, BlockBegin* b) { _loop_map.set_bit(loop_idx, b->block_id()); }
void clear_block_in_loop(int loop_idx, int block_id) { _loop_map.clear_bit(loop_idx, block_id); }
void count_edges(BlockBegin* cur, BlockBegin* parent);
void mark_loops();
void clear_non_natural_loops(BlockBegin* start_block);
void assign_loop_depth(BlockBegin* start_block);
BlockBegin* common_dominator(BlockBegin* a, BlockBegin* b);
void compute_dominator(BlockBegin* cur, BlockBegin* parent);
int compute_weight(BlockBegin* cur);
bool ready_for_processing(BlockBegin* cur);
void sort_into_work_list(BlockBegin* b);
void append_block(BlockBegin* cur);
void compute_order(BlockBegin* start_block);
bool compute_dominators_iter();
void compute_dominators();
NOT_PRODUCT(void print_blocks();)
DEBUG_ONLY(void verify();)
Compilation* compilation() const { return _compilation; }
public:
ComputeLinearScanOrder(Compilation* c, BlockBegin* start_block);
BlockList* linear_scan_order() const { return _linear_scan_order; }
int num_loops() const { return _num_loops; }
};
ComputeLinearScanOrder::ComputeLinearScanOrder(Compilation* c, BlockBegin* start_block) :
_max_block_id(BlockBegin::number_of_blocks()),
_num_blocks(0),
_num_loops(0),
_iterative_dominators(false),
_visited_blocks(_max_block_id),
_active_blocks(_max_block_id),
_dominator_blocks(_max_block_id),
_forward_branches(_max_block_id, 0),
_loop_end_blocks(8),
_work_list(8),
_linear_scan_order(NULL), // initialized later with correct size
_loop_map(0, 0), // initialized later with correct size
_compilation(c)
{
TRACE_LINEAR_SCAN(2, tty->print_cr("***** computing linear-scan block order"));
init_visited();
count_edges(start_block, NULL);
if (compilation()->is_profiling()) {
ciMethod *method = compilation()->method();
if (!method->is_accessor()) {
ciMethodData* md = method->method_data_or_null();
assert(md != NULL, "Sanity");
md->set_compilation_stats(_num_loops, _num_blocks);
}
}
if (_num_loops > 0) {
mark_loops();
clear_non_natural_loops(start_block);
assign_loop_depth(start_block);
}
compute_order(start_block);
compute_dominators();
NOT_PRODUCT(print_blocks());
DEBUG_ONLY(verify());
}
void ComputeLinearScanOrder::count_edges(BlockBegin* cur, BlockBegin* parent) {
TRACE_LINEAR_SCAN(3, tty->print_cr("Enter count_edges for block B%d coming from B%d", cur->block_id(), parent != NULL ? parent->block_id() : -1));
assert(cur->dominator() == NULL, "dominator already initialized");
if (is_active(cur)) {
TRACE_LINEAR_SCAN(3, tty->print_cr("backward branch"));
assert(is_visited(cur), "block must be visisted when block is active");
assert(parent != NULL, "must have parent");
cur->set(BlockBegin::backward_branch_target_flag);
if (cur->is_set(BlockBegin::exception_entry_flag)) {
_iterative_dominators = true;
return;
}
cur->set(BlockBegin::linear_scan_loop_header_flag);
parent->set(BlockBegin::linear_scan_loop_end_flag);
assert(parent->number_of_sux() == 1 && parent->sux_at(0) == cur,
"loop end blocks must have one successor (critical edges are split)");
_loop_end_blocks.append(parent);
return;
}
inc_forward_branches(cur);
if (is_visited(cur)) {
TRACE_LINEAR_SCAN(3, tty->print_cr("block already visited"));
return;
}
_num_blocks++;
set_visited(cur);
set_active(cur);
int i;
for (i = cur->number_of_sux() - 1; i >= 0; i--) {
count_edges(cur->sux_at(i), cur);
}
for (i = cur->number_of_exception_handlers() - 1; i >= 0; i--) {
count_edges(cur->exception_handler_at(i), cur);
}
clear_active(cur);
if (cur->is_set(BlockBegin::linear_scan_loop_header_flag)) {
assert(cur->loop_index() == -1, "cannot set loop-index twice");
TRACE_LINEAR_SCAN(3, tty->print_cr("Block B%d is loop header of loop %d", cur->block_id(), _num_loops));
cur->set_loop_index(_num_loops);
_loop_headers.append(cur);
_num_loops++;
}
TRACE_LINEAR_SCAN(3, tty->print_cr("Finished count_edges for block B%d", cur->block_id()));
}
void ComputeLinearScanOrder::mark_loops() {
TRACE_LINEAR_SCAN(3, tty->print_cr("----- marking loops"));
_loop_map = BitMap2D(_num_loops, _max_block_id);
_loop_map.clear();
for (int i = _loop_end_blocks.length() - 1; i >= 0; i--) {
BlockBegin* loop_end = _loop_end_blocks.at(i);
BlockBegin* loop_start = loop_end->sux_at(0);
int loop_idx = loop_start->loop_index();
TRACE_LINEAR_SCAN(3, tty->print_cr("Processing loop from B%d to B%d (loop %d):", loop_start->block_id(), loop_end->block_id(), loop_idx));
assert(loop_end->is_set(BlockBegin::linear_scan_loop_end_flag), "loop end flag must be set");
assert(loop_end->number_of_sux() == 1, "incorrect number of successors");
assert(loop_start->is_set(BlockBegin::linear_scan_loop_header_flag), "loop header flag must be set");
assert(loop_idx >= 0 && loop_idx < _num_loops, "loop index not set");
assert(_work_list.is_empty(), "work list must be empty before processing");
_work_list.push(loop_end);
set_block_in_loop(loop_idx, loop_end);
do {
BlockBegin* cur = _work_list.pop();
TRACE_LINEAR_SCAN(3, tty->print_cr(" processing B%d", cur->block_id()));
assert(is_block_in_loop(loop_idx, cur), "bit in loop map must be set when block is in work list");
if (cur != loop_start && !cur->is_set(BlockBegin::osr_entry_flag)) {
for (int j = cur->number_of_preds() - 1; j >= 0; j--) {
BlockBegin* pred = cur->pred_at(j);
if (!is_block_in_loop(loop_idx, pred) /*&& !pred->is_set(BlockBeginosr_entry_flag)*/) {
TRACE_LINEAR_SCAN(3, tty->print_cr(" pushing B%d", pred->block_id()));
_work_list.push(pred);
set_block_in_loop(loop_idx, pred);
}
}
}
} while (!_work_list.is_empty());
}
}
void ComputeLinearScanOrder::clear_non_natural_loops(BlockBegin* start_block) {
for (int i = _num_loops - 1; i >= 0; i--) {
if (is_block_in_loop(i, start_block)) {
TRACE_LINEAR_SCAN(2, tty->print_cr("Loop %d is non-natural, so it is ignored", i));
BlockBegin *loop_header = _loop_headers.at(i);
assert(loop_header->is_set(BlockBegin::linear_scan_loop_header_flag), "Must be loop header");
for (int j = 0; j < loop_header->number_of_preds(); j++) {
BlockBegin *pred = loop_header->pred_at(j);
pred->clear(BlockBegin::linear_scan_loop_end_flag);
}
loop_header->clear(BlockBegin::linear_scan_loop_header_flag);
for (int block_id = _max_block_id - 1; block_id >= 0; block_id--) {
clear_block_in_loop(i, block_id);
}
_iterative_dominators = true;
}
}
}
void ComputeLinearScanOrder::assign_loop_depth(BlockBegin* start_block) {
TRACE_LINEAR_SCAN(3, tty->print_cr("----- computing loop-depth and weight"));
init_visited();
assert(_work_list.is_empty(), "work list must be empty before processing");
_work_list.append(start_block);
do {
BlockBegin* cur = _work_list.pop();
if (!is_visited(cur)) {
set_visited(cur);
TRACE_LINEAR_SCAN(4, tty->print_cr("Computing loop depth for block B%d", cur->block_id()));
assert(cur->loop_depth() == 0, "cannot set loop-depth twice");
int i;
int loop_depth = 0;
int min_loop_idx = -1;
for (i = _num_loops - 1; i >= 0; i--) {
if (is_block_in_loop(i, cur)) {
loop_depth++;
min_loop_idx = i;
}
}
cur->set_loop_depth(loop_depth);
cur->set_loop_index(min_loop_idx);
for (i = cur->number_of_sux() - 1; i >= 0; i--) {
_work_list.append(cur->sux_at(i));
}
for (i = cur->number_of_exception_handlers() - 1; i >= 0; i--) {
_work_list.append(cur->exception_handler_at(i));
}
}
} while (!_work_list.is_empty());
}
BlockBegin* ComputeLinearScanOrder::common_dominator(BlockBegin* a, BlockBegin* b) {
assert(a != NULL && b != NULL, "must have input blocks");
_dominator_blocks.clear();
while (a != NULL) {
_dominator_blocks.set_bit(a->block_id());
assert(a->dominator() != NULL || a == _linear_scan_order->at(0), "dominator must be initialized");
a = a->dominator();
}
while (b != NULL && !_dominator_blocks.at(b->block_id())) {
assert(b->dominator() != NULL || b == _linear_scan_order->at(0), "dominator must be initialized");
b = b->dominator();
}
assert(b != NULL, "could not find dominator");
return b;
}
void ComputeLinearScanOrder::compute_dominator(BlockBegin* cur, BlockBegin* parent) {
if (cur->dominator() == NULL) {
TRACE_LINEAR_SCAN(4, tty->print_cr("DOM: initializing dominator of B%d to B%d", cur->block_id(), parent->block_id()));
cur->set_dominator(parent);
} else if (!(cur->is_set(BlockBegin::linear_scan_loop_header_flag) && parent->is_set(BlockBegin::linear_scan_loop_end_flag))) {
TRACE_LINEAR_SCAN(4, tty->print_cr("DOM: computing dominator of B%d: common dominator of B%d and B%d is B%d", cur->block_id(), parent->block_id(), cur->dominator()->block_id(), common_dominator(cur->dominator(), parent)->block_id()));
assert(cur->number_of_preds() > 1 || cur->is_set(BlockBegin::exception_entry_flag), "");
cur->set_dominator(common_dominator(cur->dominator(), parent));
}
int num_cur_xhandler = cur->number_of_exception_handlers();
for (int j = 0; j < num_cur_xhandler; j++) {
BlockBegin* xhandler = cur->exception_handler_at(j);
compute_dominator(xhandler, parent);
}
}
int ComputeLinearScanOrder::compute_weight(BlockBegin* cur) {
BlockBegin* single_sux = NULL;
if (cur->number_of_sux() == 1) {
single_sux = cur->sux_at(0);
}
int weight = (cur->loop_depth() & 0x7FFF) << 16;
int cur_bit = 15;
#define INC_WEIGHT_IF(condition) if ((condition)) { weight |= (1 << cur_bit); } cur_bit--;
INC_WEIGHT_IF(!cur->is_set(BlockBegin::linear_scan_loop_header_flag));
INC_WEIGHT_IF(!cur->is_set(BlockBegin::linear_scan_loop_end_flag));
INC_WEIGHT_IF(cur->is_set(BlockBegin::critical_edge_split_flag));
INC_WEIGHT_IF(cur->end()->as_Throw() == NULL && (single_sux == NULL || single_sux->end()->as_Throw() == NULL));
INC_WEIGHT_IF(cur->end()->as_Return() == NULL && (single_sux == NULL || single_sux->end()->as_Return() == NULL));
INC_WEIGHT_IF(!cur->is_set(BlockBegin::exception_entry_flag));
weight |= 1;
#undef INC_WEIGHT_IF
assert(cur_bit >= 0, "too many flags");
assert(weight > 0, "weight cannot become negative");
return weight;
}
bool ComputeLinearScanOrder::ready_for_processing(BlockBegin* cur) {
if (dec_forward_branches(cur) != 0) {
return false;
}
assert(_linear_scan_order->index_of(cur) == -1, "block already processed (block can be ready only once)");
assert(_work_list.index_of(cur) == -1, "block already in work-list (block can be ready only once)");
return true;
}
void ComputeLinearScanOrder::sort_into_work_list(BlockBegin* cur) {
assert(_work_list.index_of(cur) == -1, "block already in work list");
int cur_weight = compute_weight(cur);
cur->set_linear_scan_number(cur_weight);
#ifndef PRODUCT
if (StressLinearScan) {
_work_list.insert_before(0, cur);
return;
}
#endif
_work_list.append(NULL); // provide space for new element
int insert_idx = _work_list.length() - 1;
while (insert_idx > 0 && _work_list.at(insert_idx - 1)->linear_scan_number() > cur_weight) {
_work_list.at_put(insert_idx, _work_list.at(insert_idx - 1));
insert_idx--;
}
_work_list.at_put(insert_idx, cur);
TRACE_LINEAR_SCAN(3, tty->print_cr("Sorted B%d into worklist. new worklist:", cur->block_id()));
TRACE_LINEAR_SCAN(3, for (int i = 0; i < _work_list.length(); i++) tty->print_cr("%8d B%2d weight:%6x", i, _work_list.at(i)->block_id(), _work_list.at(i)->linear_scan_number()));
#ifdef ASSERT
for (int i = 0; i < _work_list.length(); i++) {
assert(_work_list.at(i)->linear_scan_number() > 0, "weight not set");
assert(i == 0 || _work_list.at(i - 1)->linear_scan_number() <= _work_list.at(i)->linear_scan_number(), "incorrect order in worklist");
}
#endif
}
void ComputeLinearScanOrder::append_block(BlockBegin* cur) {
TRACE_LINEAR_SCAN(3, tty->print_cr("appending block B%d (weight 0x%6x) to linear-scan order", cur->block_id(), cur->linear_scan_number()));
assert(_linear_scan_order->index_of(cur) == -1, "cannot add the same block twice");
cur->set_linear_scan_number(_linear_scan_order->length());
_linear_scan_order->append(cur);
}
void ComputeLinearScanOrder::compute_order(BlockBegin* start_block) {
TRACE_LINEAR_SCAN(3, tty->print_cr("----- computing final block order"));
_linear_scan_order = new BlockList(_num_blocks);
append_block(start_block);
assert(start_block->end()->as_Base() != NULL, "start block must end with Base-instruction");
BlockBegin* std_entry = ((Base*)start_block->end())->std_entry();
BlockBegin* osr_entry = ((Base*)start_block->end())->osr_entry();
BlockBegin* sux_of_osr_entry = NULL;
if (osr_entry != NULL) {
assert(osr_entry->number_of_sux() == 1, "osr entry must have exactly one successor");
assert(osr_entry->sux_at(0)->number_of_preds() >= 2, "sucessor of osr entry must have two predecessors (otherwise it is not present in normal control flow");
sux_of_osr_entry = osr_entry->sux_at(0);
dec_forward_branches(sux_of_osr_entry);
compute_dominator(osr_entry, start_block);
_iterative_dominators = true;
}
compute_dominator(std_entry, start_block);
assert(_work_list.is_empty(), "list must be empty before processing");
if (ready_for_processing(std_entry)) {
sort_into_work_list(std_entry);
} else {
assert(false, "the std_entry must be ready for processing (otherwise, the method has no start block)");
}
do {
BlockBegin* cur = _work_list.pop();
if (cur == sux_of_osr_entry) {
append_block(osr_entry);
compute_dominator(cur, osr_entry);
}
append_block(cur);
int i;
int num_sux = cur->number_of_sux();
for (i = 0; i < num_sux; i++) {
BlockBegin* sux = cur->sux_at(i);
compute_dominator(sux, cur);
if (ready_for_processing(sux)) {
sort_into_work_list(sux);
}
}
num_sux = cur->number_of_exception_handlers();
for (i = 0; i < num_sux; i++) {
BlockBegin* sux = cur->exception_handler_at(i);
if (ready_for_processing(sux)) {
sort_into_work_list(sux);
}
}
} while (_work_list.length() > 0);
}
bool ComputeLinearScanOrder::compute_dominators_iter() {
bool changed = false;
int num_blocks = _linear_scan_order->length();
assert(_linear_scan_order->at(0)->dominator() == NULL, "must not have dominator");
assert(_linear_scan_order->at(0)->number_of_preds() == 0, "must not have predecessors");
for (int i = 1; i < num_blocks; i++) {
BlockBegin* block = _linear_scan_order->at(i);
BlockBegin* dominator = block->pred_at(0);
int num_preds = block->number_of_preds();
TRACE_LINEAR_SCAN(4, tty->print_cr("DOM: Processing B%d", block->block_id()));
for (int j = 0; j < num_preds; j++) {
BlockBegin *pred = block->pred_at(j);
TRACE_LINEAR_SCAN(4, tty->print_cr(" DOM: Subrocessing B%d", pred->block_id()));
if (block->is_set(BlockBegin::exception_entry_flag)) {
dominator = common_dominator(dominator, pred);
int num_pred_preds = pred->number_of_preds();
for (int k = 0; k < num_pred_preds; k++) {
dominator = common_dominator(dominator, pred->pred_at(k));
}
} else {
dominator = common_dominator(dominator, pred);
}
}
if (dominator != block->dominator()) {
TRACE_LINEAR_SCAN(4, tty->print_cr("DOM: updating dominator of B%d from B%d to B%d", block->block_id(), block->dominator()->block_id(), dominator->block_id()));
block->set_dominator(dominator);
changed = true;
}
}
return changed;
}
void ComputeLinearScanOrder::compute_dominators() {
TRACE_LINEAR_SCAN(3, tty->print_cr("----- computing dominators (iterative computation reqired: %d)", _iterative_dominators));
if (_iterative_dominators) {
do {
TRACE_LINEAR_SCAN(1, tty->print_cr("DOM: next iteration of fix-point calculation"));
} while (compute_dominators_iter());
}
assert(!compute_dominators_iter(), "fix point not reached");
int num_blocks = _linear_scan_order->length();
for (int i = 0; i < num_blocks; i++) {
BlockBegin* block = _linear_scan_order->at(i);
BlockBegin *dom = block->dominator();
if (dom) {
assert(dom->dominator_depth() != -1, "Dominator must have been visited before");
dom->dominates()->append(block);
block->set_dominator_depth(dom->dominator_depth() + 1);
} else {
block->set_dominator_depth(0);
}
}
}
#ifndef PRODUCT
void ComputeLinearScanOrder::print_blocks() {
if (TraceLinearScanLevel >= 2) {
tty->print_cr("----- loop information:");
for (int block_idx = 0; block_idx < _linear_scan_order->length(); block_idx++) {
BlockBegin* cur = _linear_scan_order->at(block_idx);
tty->print("%4d: B%2d: ", cur->linear_scan_number(), cur->block_id());
for (int loop_idx = 0; loop_idx < _num_loops; loop_idx++) {
tty->print ("%d ", is_block_in_loop(loop_idx, cur));
}
tty->print_cr(" -> loop_index: %2d, loop_depth: %2d", cur->loop_index(), cur->loop_depth());
}
}
if (TraceLinearScanLevel >= 1) {
tty->print_cr("----- linear-scan block order:");
for (int block_idx = 0; block_idx < _linear_scan_order->length(); block_idx++) {
BlockBegin* cur = _linear_scan_order->at(block_idx);
tty->print("%4d: B%2d loop: %2d depth: %2d", cur->linear_scan_number(), cur->block_id(), cur->loop_index(), cur->loop_depth());
tty->print(cur->is_set(BlockBegin::exception_entry_flag) ? " ex" : " ");
tty->print(cur->is_set(BlockBegin::critical_edge_split_flag) ? " ce" : " ");
tty->print(cur->is_set(BlockBegin::linear_scan_loop_header_flag) ? " lh" : " ");
tty->print(cur->is_set(BlockBegin::linear_scan_loop_end_flag) ? " le" : " ");
if (cur->dominator() != NULL) {
tty->print(" dom: B%d ", cur->dominator()->block_id());
} else {
tty->print(" dom: NULL ");
}
if (cur->number_of_preds() > 0) {
tty->print(" preds: ");
for (int j = 0; j < cur->number_of_preds(); j++) {
BlockBegin* pred = cur->pred_at(j);
tty->print("B%d ", pred->block_id());
}
}
if (cur->number_of_sux() > 0) {
tty->print(" sux: ");
for (int j = 0; j < cur->number_of_sux(); j++) {
BlockBegin* sux = cur->sux_at(j);
tty->print("B%d ", sux->block_id());
}
}
if (cur->number_of_exception_handlers() > 0) {
tty->print(" ex: ");
for (int j = 0; j < cur->number_of_exception_handlers(); j++) {
BlockBegin* ex = cur->exception_handler_at(j);
tty->print("B%d ", ex->block_id());
}
}
tty->cr();
}
}
}
#endif
#ifdef ASSERT
void ComputeLinearScanOrder::verify() {
assert(_linear_scan_order->length() == _num_blocks, "wrong number of blocks in list");
if (StressLinearScan) {
return;
}
int i;
for (i = 0; i < _linear_scan_order->length(); i++) {
BlockBegin* cur = _linear_scan_order->at(i);
assert(cur->linear_scan_number() == i, "incorrect linear_scan_number");
assert(cur->linear_scan_number() >= 0 && cur->linear_scan_number() == _linear_scan_order->index_of(cur), "incorrect linear_scan_number");
int j;
for (j = cur->number_of_sux() - 1; j >= 0; j--) {
BlockBegin* sux = cur->sux_at(j);
assert(sux->linear_scan_number() >= 0 && sux->linear_scan_number() == _linear_scan_order->index_of(sux), "incorrect linear_scan_number");
if (!sux->is_set(BlockBegin::backward_branch_target_flag)) {
assert(cur->linear_scan_number() < sux->linear_scan_number(), "invalid order");
}
if (cur->loop_depth() == sux->loop_depth()) {
assert(cur->loop_index() == sux->loop_index() || sux->is_set(BlockBegin::linear_scan_loop_header_flag), "successing blocks with same loop depth must have same loop index");
}
}
for (j = cur->number_of_preds() - 1; j >= 0; j--) {
BlockBegin* pred = cur->pred_at(j);
assert(pred->linear_scan_number() >= 0 && pred->linear_scan_number() == _linear_scan_order->index_of(pred), "incorrect linear_scan_number");
if (!cur->is_set(BlockBegin::backward_branch_target_flag)) {
assert(cur->linear_scan_number() > pred->linear_scan_number(), "invalid order");
}
if (cur->loop_depth() == pred->loop_depth()) {
assert(cur->loop_index() == pred->loop_index() || cur->is_set(BlockBegin::linear_scan_loop_header_flag), "successing blocks with same loop depth must have same loop index");
}
assert(cur->dominator()->linear_scan_number() <= cur->pred_at(j)->linear_scan_number(), "dominator must be before predecessors");
}
if (i == 0) {
assert(cur->dominator() == NULL, "first block has no dominator");
} else {
assert(cur->dominator() != NULL, "all but first block must have dominator");
}
assert(cur->number_of_preds() != 1 || cur->dominator() == cur->pred_at(0) || cur->is_set(BlockBegin::exception_entry_flag), "Single predecessor must also be dominator");
}
for (int loop_idx = 0; loop_idx < _num_loops; loop_idx++) {
int block_idx = 0;
assert(!is_block_in_loop(loop_idx, _linear_scan_order->at(block_idx)), "the first block must not be present in any loop");
while (block_idx < _num_blocks && !is_block_in_loop(loop_idx, _linear_scan_order->at(block_idx))) {
block_idx++;
}
while (block_idx < _num_blocks && is_block_in_loop(loop_idx, _linear_scan_order->at(block_idx))) {
block_idx++;
}
while (block_idx < _num_blocks) {
assert(!is_block_in_loop(loop_idx, _linear_scan_order->at(block_idx)), "loop not continuous in linear-scan order");
block_idx++;
}
}
}
#endif
void IR::compute_code() {
assert(is_valid(), "IR must be valid");
ComputeLinearScanOrder compute_order(compilation(), start());
_num_loops = compute_order.num_loops();
_code = compute_order.linear_scan_order();
}
void IR::compute_use_counts() {
int num_blocks = _code->length();
for (int i = 0; i < num_blocks; i++) {
_code->at(i)->end()->state()->pin_stack_for_linear_scan();
}
UseCountComputer::compute(_code);
}
void IR::iterate_preorder(BlockClosure* closure) {
assert(is_valid(), "IR must be valid");
start()->iterate_preorder(closure);
}
void IR::iterate_postorder(BlockClosure* closure) {
assert(is_valid(), "IR must be valid");
start()->iterate_postorder(closure);
}
void IR::iterate_linear_scan_order(BlockClosure* closure) {
linear_scan_order()->iterate_forward(closure);
}
#ifndef PRODUCT
class BlockPrinter: public BlockClosure {
private:
InstructionPrinter* _ip;
bool _cfg_only;
bool _live_only;
public:
BlockPrinter(InstructionPrinter* ip, bool cfg_only, bool live_only = false) {
_ip = ip;
_cfg_only = cfg_only;
_live_only = live_only;
}
virtual void block_do(BlockBegin* block) {
if (_cfg_only) {
_ip->print_instr(block); tty->cr();
} else {
block->print_block(*_ip, _live_only);
}
}
};
void IR::print(BlockBegin* start, bool cfg_only, bool live_only) {
ttyLocker ttyl;
InstructionPrinter ip(!cfg_only);
BlockPrinter bp(&ip, cfg_only, live_only);
start->iterate_preorder(&bp);
tty->cr();
}
void IR::print(bool cfg_only, bool live_only) {
if (is_valid()) {
print(start(), cfg_only, live_only);
} else {
tty->print_cr("invalid IR");
}
}
define_array(BlockListArray, BlockList*)
define_stack(BlockListList, BlockListArray)
class PredecessorValidator : public BlockClosure {
private:
BlockListList* _predecessors;
BlockList* _blocks;
static int cmp(BlockBegin** a, BlockBegin** b) {
return (*a)->block_id() - (*b)->block_id();
}
public:
PredecessorValidator(IR* hir) {
ResourceMark rm;
_predecessors = new BlockListList(BlockBegin::number_of_blocks(), NULL);
_blocks = new BlockList();
int i;
hir->start()->iterate_preorder(this);
if (hir->code() != NULL) {
assert(hir->code()->length() == _blocks->length(), "must match");
for (i = 0; i < _blocks->length(); i++) {
assert(hir->code()->contains(_blocks->at(i)), "should be in both lists");
}
}
for (i = 0; i < _blocks->length(); i++) {
BlockBegin* block = _blocks->at(i);
BlockList* preds = _predecessors->at(block->block_id());
if (preds == NULL) {
assert(block->number_of_preds() == 0, "should be the same");
continue;
}
BlockList* pred_copy = new BlockList();
int j;
for (j = 0; j < block->number_of_preds(); j++) {
pred_copy->append(block->pred_at(j));
}
preds->sort(cmp);
pred_copy->sort(cmp);
int length = MIN2(preds->length(), block->number_of_preds());
for (j = 0; j < block->number_of_preds(); j++) {
assert(preds->at(j) == pred_copy->at(j), "must match");
}
assert(preds->length() == block->number_of_preds(), "should be the same");
}
}
virtual void block_do(BlockBegin* block) {
_blocks->append(block);
BlockEnd* be = block->end();
int n = be->number_of_sux();
int i;
for (i = 0; i < n; i++) {
BlockBegin* sux = be->sux_at(i);
assert(!sux->is_set(BlockBegin::exception_entry_flag), "must not be xhandler");
BlockList* preds = _predecessors->at_grow(sux->block_id(), NULL);
if (preds == NULL) {
preds = new BlockList();
_predecessors->at_put(sux->block_id(), preds);
}
preds->append(block);
}
n = block->number_of_exception_handlers();
for (i = 0; i < n; i++) {
BlockBegin* sux = block->exception_handler_at(i);
assert(sux->is_set(BlockBegin::exception_entry_flag), "must be xhandler");
BlockList* preds = _predecessors->at_grow(sux->block_id(), NULL);
if (preds == NULL) {
preds = new BlockList();
_predecessors->at_put(sux->block_id(), preds);
}
preds->append(block);
}
}
};
class VerifyBlockBeginField : public BlockClosure {
public:
virtual void block_do(BlockBegin *block) {
for ( Instruction *cur = block; cur != NULL; cur = cur->next()) {
assert(cur->block() == block, "Block begin is not correct");
}
}
};
void IR::verify() {
#ifdef ASSERT
PredecessorValidator pv(this);
VerifyBlockBeginField verifier;
this->iterate_postorder(&verifier);
#endif
}
#endif // PRODUCT
void SubstitutionResolver::visit(Value* v) {
Value v0 = *v;
if (v0) {
Value vs = v0->subst();
if (vs != v0) {
}
}
}
#ifdef ASSERT
class SubstitutionChecker: public ValueVisitor {
void visit(Value* v) {
Value v0 = *v;
if (v0) {
Value vs = v0->subst();
assert(vs == v0, "missed substitution");
}
}
};
#endif
void SubstitutionResolver::block_do(BlockBegin* block) {
Instruction* last = NULL;
for (Instruction* n = block; n != NULL;) {
n->values_do(this);
if (n->subst() != n) {
assert(last != NULL, "must have last");
last->set_next(n->next());
} else {
last = n;
}
n = last->next();
}
#ifdef ASSERT
SubstitutionChecker check_substitute;
if (block->state()) block->state()->values_do(&check_substitute);
block->block_values_do(&check_substitute);
if (block->end() && block->end()->state()) block->end()->state()->values_do(&check_substitute);
#endif
}
C:\hotspot-69087d08d473\src\share\vm/c1/c1_IR.hpp
#ifndef SHARE_VM_C1_C1_IR_HPP
#define SHARE_VM_C1_C1_IR_HPP
#include "c1/c1_Instruction.hpp"
#include "ci/ciExceptionHandler.hpp"
#include "ci/ciMethod.hpp"
#include "ci/ciStreams.hpp"
#include "memory/allocation.hpp"
class XHandler: public CompilationResourceObj {
private:
ciExceptionHandler* _desc;
BlockBegin* _entry_block; // Entry block of xhandler
LIR_List* _entry_code; // LIR-operations that must be executed before jumping to entry_block
int _entry_pco; // pco where entry_code (or entry_block if no entry_code) starts
int _phi_operand; // For resolving of phi functions at begin of entry_block
int _scope_count; // for filling ExceptionRangeEntry::scope_count
#ifdef ASSERT
int _lir_op_id; // op_id of the LIR-operation throwing to this handler
#endif
public:
XHandler(ciExceptionHandler* desc)
: _desc(desc)
, _entry_block(NULL)
, _entry_code(NULL)
, _entry_pco(-1)
, _phi_operand(-1)
, _scope_count(-1)
#ifdef ASSERT
, _lir_op_id(-1)
#endif
{ }
XHandler(XHandler* other)
: _desc(other->_desc)
, _entry_block(other->_entry_block)
, _entry_code(other->_entry_code)
, _entry_pco(other->_entry_pco)
, _phi_operand(other->_phi_operand)
, _scope_count(other->_scope_count)
#ifdef ASSERT
, _lir_op_id(other->_lir_op_id)
#endif
{ }
int beg_bci() const { return _desc->start(); }
int end_bci() const { return _desc->limit(); }
int handler_bci() const { return _desc->handler_bci(); }
bool is_catch_all() const { return _desc->is_catch_all(); }
int catch_type() const { return _desc->catch_klass_index(); }
ciInstanceKlass* catch_klass() const { return _desc->catch_klass(); }
bool covers(int bci) const { return beg_bci() <= bci && bci < end_bci(); }
BlockBegin* entry_block() const { return _entry_block; }
LIR_List* entry_code() const { return _entry_code; }
int entry_pco() const { return _entry_pco; }
int phi_operand() const { assert(_phi_operand != -1, "not set"); return _phi_operand; }
int scope_count() const { assert(_scope_count != -1, "not set"); return _scope_count; }
DEBUG_ONLY(int lir_op_id() const { return _lir_op_id; });
void set_entry_block(BlockBegin* entry_block) {
assert(entry_block->is_set(BlockBegin::exception_entry_flag), "must be an exception handler entry");
assert(entry_block->bci() == handler_bci(), "bci's must correspond");
_entry_block = entry_block;
}
void set_entry_code(LIR_List* entry_code) { _entry_code = entry_code; }
void set_entry_pco(int entry_pco) { _entry_pco = entry_pco; }
void set_phi_operand(int phi_operand) { _phi_operand = phi_operand; }
void set_scope_count(int scope_count) { _scope_count = scope_count; }
DEBUG_ONLY(void set_lir_op_id(int lir_op_id) { _lir_op_id = lir_op_id; });
bool equals(XHandler* other) const;
};
define_array(_XHandlerArray, XHandler*)
define_stack(_XHandlerList, _XHandlerArray)
class XHandlers: public CompilationResourceObj {
private:
_XHandlerList _list;
public:
XHandlers() : _list() { }
XHandlers(ciMethod* method);
XHandlers(XHandlers* other);
int length() const { return _list.length(); }
XHandler* handler_at(int i) const { return _list.at(i); }
bool has_handlers() const { return _list.length() > 0; }
void append(XHandler* h) { _list.append(h); }
XHandler* remove_last() { return _list.pop(); }
bool could_catch(ciInstanceKlass* klass, bool type_is_exact) const;
bool equals(XHandlers* others) const;
};
class IRScope;
define_array(IRScopeArray, IRScope*)
define_stack(IRScopeList, IRScopeArray)
class Compilation;
class IRScope: public CompilationResourceObj {
private:
Compilation* _compilation; // the current compilation
IRScope* _caller; // the caller scope, or NULL
int _level; // the inlining level
ciMethod* _method; // the corresponding method
IRScopeList _callees; // the inlined method scopes
XHandlers* _xhandlers; // the exception handlers
int _number_of_locks; // the number of monitor lock slots needed
bool _monitor_pairing_ok; // the monitor pairing info
bool _wrote_final; // has written final field
BlockBegin* _start; // the start block, successsors are method entries
BitMap _requires_phi_function; // bit is set if phi functions at loop headers are necessary for a local variable
BlockBegin* build_graph(Compilation* compilation, int osr_bci);
public:
IRScope(Compilation* compilation, IRScope* caller, int caller_bci, ciMethod* method, int osr_bci, bool create_graph = false);
Compilation* compilation() const { return _compilation; }
IRScope* caller() const { return _caller; }
int level() const { return _level; }
ciMethod* method() const { return _method; }
int max_stack() const; // NOTE: expensive
BitMap& requires_phi_function() { return _requires_phi_function; }
bool is_top_scope() const { return _caller == NULL; }
void add_callee(IRScope* callee) { _callees.append(callee); }
int number_of_callees() const { return _callees.length(); }
IRScope* callee_no(int i) const { return _callees.at(i); }
bool is_valid() const { return start() != NULL; }
XHandlers* xhandlers() const { return _xhandlers; }
int number_of_locks() const { return _number_of_locks; }
void set_min_number_of_locks(int n) { if (n > _number_of_locks) _number_of_locks = n; }
bool monitor_pairing_ok() const { return _monitor_pairing_ok; }
BlockBegin* start() const { return _start; }
void set_wrote_final() { _wrote_final = true; }
bool wrote_final () const { return _wrote_final; }
};
class IRScopeDebugInfo: public CompilationResourceObj {
private:
IRScope* _scope;
int _bci;
GrowableArray<ScopeValue*>* _locals;
GrowableArray<ScopeValue*>* _expressions;
GrowableArray<MonitorValue*>* _monitors;
IRScopeDebugInfo* _caller;
public:
IRScopeDebugInfo(IRScope* scope,
int bci,
GrowableArray<ScopeValue*>* locals,
GrowableArray<ScopeValue*>* expressions,
GrowableArray<MonitorValue*>* monitors,
IRScopeDebugInfo* caller):
_scope(scope)
, _locals(locals)
, _bci(bci)
, _expressions(expressions)
, _monitors(monitors)
, _caller(caller) {}
IRScope* scope() { return _scope; }
int bci() { return _bci; }
GrowableArray<ScopeValue*>* locals() { return _locals; }
GrowableArray<ScopeValue*>* expressions() { return _expressions; }
GrowableArray<MonitorValue*>* monitors() { return _monitors; }
IRScopeDebugInfo* caller() { return _caller; }
bool should_reexecute();
void record_debug_info(DebugInformationRecorder* recorder, int pc_offset, bool topmost, bool is_method_handle_invoke = false) {
if (caller() != NULL) {
caller()->record_debug_info(recorder, pc_offset, false/*topmost*/);
}
DebugToken* locvals = recorder->create_scope_values(locals());
DebugToken* expvals = recorder->create_scope_values(expressions());
DebugToken* monvals = recorder->create_monitor_values(monitors());
bool reexecute = topmost ? should_reexecute() : false;
bool return_oop = false; // This flag will be ignored since it used only for C2 with escape analysis.
recorder->describe_scope(pc_offset, scope()->method(), bci(), reexecute, is_method_handle_invoke, return_oop, locvals, expvals, monvals);
}
};
class CodeEmitInfo: public CompilationResourceObj {
friend class LinearScan;
private:
IRScopeDebugInfo* _scope_debug_info;
IRScope* _scope;
XHandlers* _exception_handlers;
OopMap* _oop_map;
ValueStack* _stack; // used by deoptimization (contains also monitors
bool _is_method_handle_invoke; // true if the associated call site is a MethodHandle call site.
bool _deoptimize_on_exception;
FrameMap* frame_map() const { return scope()->compilation()->frame_map(); }
Compilation* compilation() const { return scope()->compilation(); }
public:
CodeEmitInfo(ValueStack* stack, XHandlers* exception_handlers, bool deoptimize_on_exception = false);
CodeEmitInfo(CodeEmitInfo* info, ValueStack* stack = NULL);
OopMap* oop_map() { return _oop_map; }
ciMethod* method() const { return _scope->method(); }
IRScope* scope() const { return _scope; }
XHandlers* exception_handlers() const { return _exception_handlers; }
ValueStack* stack() const { return _stack; }
bool deoptimize_on_exception() const { return _deoptimize_on_exception; }
void add_register_oop(LIR_Opr opr);
void record_debug_info(DebugInformationRecorder* recorder, int pc_offset);
bool is_method_handle_invoke() const { return _is_method_handle_invoke; }
void set_is_method_handle_invoke(bool x) { _is_method_handle_invoke = x; }
int interpreter_frame_size() const;
};
class IR: public CompilationResourceObj {
private:
Compilation* _compilation; // the current compilation
IRScope* _top_scope; // the root of the scope hierarchy
WordSize _locals_size; // the space required for all locals
int _num_loops; // Total number of loops
BlockList* _code; // the blocks in code generation order w/ use counts
public:
IR(Compilation* compilation, ciMethod* method, int osr_bci);
bool is_valid() const { return top_scope()->is_valid(); }
Compilation* compilation() const { return _compilation; }
IRScope* top_scope() const { return _top_scope; }
int number_of_locks() const { return top_scope()->number_of_locks(); }
ciMethod* method() const { return top_scope()->method(); }
BlockBegin* start() const { return top_scope()->start(); }
BlockBegin* std_entry() const { return start()->end()->as_Base()->std_entry(); }
BlockBegin* osr_entry() const { return start()->end()->as_Base()->osr_entry(); }
WordSize locals_size() const { return _locals_size; }
int locals_size_in_words() const { return in_words(_locals_size); }
BlockList* code() const { return _code; }
int num_loops() const { return _num_loops; }
int max_stack() const { return top_scope()->max_stack(); } // expensive
void optimize_blocks();
void eliminate_null_checks();
void compute_predecessors();
void split_critical_edges();
void compute_code();
void compute_use_counts();
BlockList* linear_scan_order() { assert(_code != NULL, "not computed"); return _code; }
void iterate_preorder (BlockClosure* closure);
void iterate_postorder (BlockClosure* closure);
void iterate_linear_scan_order(BlockClosure* closure);
static void print(BlockBegin* start, bool cfg_only, bool live_only = false) PRODUCT_RETURN;
void print(bool cfg_only, bool live_only = false) PRODUCT_RETURN;
void verify() PRODUCT_RETURN;
};
class SubstitutionResolver: public BlockClosure, ValueVisitor {
virtual void visit(Value* v);
public:
SubstitutionResolver(IR* hir) {
hir->iterate_preorder(this);
}
SubstitutionResolver(BlockBegin* block) {
block->iterate_preorder(this);
}
virtual void block_do(BlockBegin* block);
};
#endif // SHARE_VM_C1_C1_IR_HPP
C:\hotspot-69087d08d473\src\share\vm/c1/c1_LinearScan.cpp
#include "precompiled.hpp"
#include "c1/c1_CFGPrinter.hpp"
#include "c1/c1_CodeStubs.hpp"
#include "c1/c1_Compilation.hpp"
#include "c1/c1_FrameMap.hpp"
#include "c1/c1_IR.hpp"
#include "c1/c1_LIRGenerator.hpp"
#include "c1/c1_LinearScan.hpp"
#include "c1/c1_ValueStack.hpp"
#include "utilities/bitMap.inline.hpp"
#ifdef TARGET_ARCH_x86
# include "vmreg_x86.inline.hpp"
#endif
#ifdef TARGET_ARCH_aarch64
# include "vmreg_aarch64.inline.hpp"
#endif
#ifdef TARGET_ARCH_sparc
# include "vmreg_sparc.inline.hpp"
#endif
#ifdef TARGET_ARCH_zero
# include "vmreg_zero.inline.hpp"
#endif
#ifdef TARGET_ARCH_arm
# include "vmreg_arm.inline.hpp"
#endif
#ifdef TARGET_ARCH_ppc
# include "vmreg_ppc.inline.hpp"
#endif
#ifndef PRODUCT
static LinearScanStatistic _stat_before_alloc;
static LinearScanStatistic _stat_after_asign;
static LinearScanStatistic _stat_final;
static LinearScanTimers _total_timer;
#define TIME_LINEAR_SCAN(timer_name) TraceTime _block_timer("", _total_timer.timer(LinearScanTimers::timer_name), TimeLinearScan || TimeEachLinearScan, Verbose);
#define TRACE_LINEAR_SCAN(level, code) \
if (TraceLinearScanLevel >= level) { \
code; \
}
#else
#define TIME_LINEAR_SCAN(timer_name)
#define TRACE_LINEAR_SCAN(level, code)
#endif
#ifdef _LP64
static int type2spill_size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 2, 2, 0, 2, 1, 2, 1, -1};
#else
static int type2spill_size[T_CONFLICT+1]={ -1, 0, 0, 0, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 0, 1, -1, 1, 1, -1};
#endif
LinearScan::LinearScan(IR* ir, LIRGenerator* gen, FrameMap* frame_map)
: _compilation(ir->compilation())
, _ir(ir)
, _gen(gen)
, _frame_map(frame_map)
, _num_virtual_regs(gen->max_virtual_register_number())
, _has_fpu_registers(false)
, _num_calls(-1)
, _max_spills(0)
, _unused_spill_slot(-1)
, _intervals(0) // initialized later with correct length
, _new_intervals_from_allocation(new IntervalList())
, _sorted_intervals(NULL)
, _needs_full_resort(false)
, _lir_ops(0) // initialized later with correct length
, _block_of_op(0) // initialized later with correct length
, _has_info(0)
, _has_call(0)
, _scope_value_cache(0) // initialized later with correct length
, _interval_in_loop(0, 0) // initialized later with correct length
, _cached_blocks(*ir->linear_scan_order())
#ifdef X86
, _fpu_stack_allocator(NULL)
#endif
{
assert(this->ir() != NULL, "check if valid");
assert(this->compilation() != NULL, "check if valid");
assert(this->gen() != NULL, "check if valid");
assert(this->frame_map() != NULL, "check if valid");
}
int LinearScan::reg_num(LIR_Opr opr) {
assert(opr->is_register(), "should not call this otherwise");
if (opr->is_virtual_register()) {
assert(opr->vreg_number() >= nof_regs, "found a virtual register with a fixed-register number");
return opr->vreg_number();
} else if (opr->is_single_cpu()) {
return opr->cpu_regnr();
} else if (opr->is_double_cpu()) {
return opr->cpu_regnrLo();
#ifdef X86
} else if (opr->is_single_xmm()) {
return opr->fpu_regnr() + pd_first_xmm_reg;
} else if (opr->is_double_xmm()) {
return opr->fpu_regnrLo() + pd_first_xmm_reg;
#endif
} else if (opr->is_single_fpu()) {
return opr->fpu_regnr() + pd_first_fpu_reg;
} else if (opr->is_double_fpu()) {
return opr->fpu_regnrLo() + pd_first_fpu_reg;
} else {
ShouldNotReachHere();
return -1;
}
}
int LinearScan::reg_numHi(LIR_Opr opr) {
assert(opr->is_register(), "should not call this otherwise");
if (opr->is_virtual_register()) {
return -1;
} else if (opr->is_single_cpu()) {
return -1;
} else if (opr->is_double_cpu()) {
return opr->cpu_regnrHi();
#ifdef X86
} else if (opr->is_single_xmm()) {
return -1;
} else if (opr->is_double_xmm()) {
return -1;
#endif
} else if (opr->is_single_fpu()) {
return -1;
} else if (opr->is_double_fpu()) {
return opr->fpu_regnrHi() + pd_first_fpu_reg;
} else {
ShouldNotReachHere();
return -1;
}
}
bool LinearScan::is_precolored_interval(const Interval* i) {
return i->reg_num() < LinearScan::nof_regs;
}
bool LinearScan::is_virtual_interval(const Interval* i) {
return i->reg_num() >= LIR_OprDesc::vreg_base;
}
bool LinearScan::is_precolored_cpu_interval(const Interval* i) {
return i->reg_num() < LinearScan::nof_cpu_regs;
}
bool LinearScan::is_virtual_cpu_interval(const Interval* i) {
#if defined(__SOFTFP__) || defined(E500V2)
return i->reg_num() >= LIR_OprDesc::vreg_base;
#else
return i->reg_num() >= LIR_OprDesc::vreg_base && (i->type() != T_FLOAT && i->type() != T_DOUBLE);
#endif // __SOFTFP__ or E500V2
}
bool LinearScan::is_precolored_fpu_interval(const Interval* i) {
return i->reg_num() >= LinearScan::nof_cpu_regs && i->reg_num() < LinearScan::nof_regs;
}
bool LinearScan::is_virtual_fpu_interval(const Interval* i) {
#if defined(__SOFTFP__) || defined(E500V2)
return false;
#else
return i->reg_num() >= LIR_OprDesc::vreg_base && (i->type() == T_FLOAT || i->type() == T_DOUBLE);
#endif // __SOFTFP__ or E500V2
}
bool LinearScan::is_in_fpu_register(const Interval* i) {
return i->reg_num() >= nof_regs && pd_first_fpu_reg <= i->assigned_reg() && i->assigned_reg() <= pd_last_fpu_reg;
}
bool LinearScan::is_oop_interval(const Interval* i) {
return i->reg_num() >= nof_regs && i->type() == T_OBJECT;
}
int LinearScan::allocate_spill_slot(bool double_word) {
int spill_slot;
if (double_word) {
if ((_max_spills & 1) == 1) {
assert(_unused_spill_slot == -1, "wasting a spill slot");
_unused_spill_slot = _max_spills;
_max_spills++;
}
spill_slot = _max_spills;
_max_spills += 2;
} else if (_unused_spill_slot != -1) {
spill_slot = _unused_spill_slot;
_unused_spill_slot = -1;
} else {
spill_slot = _max_spills;
_max_spills++;
}
int result = spill_slot + LinearScan::nof_regs + frame_map()->argcount();
if (result > 2000) {
bailout("too many stack slots used");
}
return result;
}
void LinearScan::assign_spill_slot(Interval* it) {
if (it->canonical_spill_slot() >= 0) {
it->assign_reg(it->canonical_spill_slot());
} else {
int spill = allocate_spill_slot(type2spill_size[it->type()] == 2);
it->set_canonical_spill_slot(spill);
it->assign_reg(spill);
}
}
void LinearScan::propagate_spill_slots() {
if (!frame_map()->finalize_frame(max_spills())) {
bailout("frame too large");
}
}
Interval* LinearScan::create_interval(int reg_num) {
assert(_intervals.at(reg_num) == NULL, "overwriting exisiting interval");
Interval* interval = new Interval(reg_num);
_intervals.at_put(reg_num, interval);
if (reg_num < LIR_OprDesc::vreg_base) {
interval->assign_reg(reg_num);
}
return interval;
}
void LinearScan::append_interval(Interval* it) {
it->set_reg_num(_intervals.length());
_intervals.append(it);
_new_intervals_from_allocation->append(it);
}
void LinearScan::copy_register_flags(Interval* from, Interval* to) {
if (gen()->is_vreg_flag_set(from->reg_num(), LIRGenerator::byte_reg)) {
gen()->set_vreg_flag(to->reg_num(), LIRGenerator::byte_reg);
}
if (gen()->is_vreg_flag_set(from->reg_num(), LIRGenerator::callee_saved)) {
gen()->set_vreg_flag(to->reg_num(), LIRGenerator::callee_saved);
}
}
void LinearScan::change_spill_definition_pos(Interval* interval, int def_pos) {
assert(interval->is_split_parent(), "can only be called for split parents");
switch (interval->spill_state()) {
case noDefinitionFound:
assert(interval->spill_definition_pos() == -1, "must no be set before");
interval->set_spill_definition_pos(def_pos);
interval->set_spill_state(oneDefinitionFound);
break;
case oneDefinitionFound:
assert(def_pos <= interval->spill_definition_pos(), "positions are processed in reverse order when intervals are created");
if (def_pos < interval->spill_definition_pos() - 2) {
interval->set_spill_state(noOptimization);
} else {
assert(block_of_op_with_id(def_pos) == block_of_op_with_id(interval->spill_definition_pos()), "block must be equal");
}
break;
case noOptimization:
break;
default:
assert(false, "other states not allowed at this time");
}
}
void LinearScan::change_spill_state(Interval* interval, int spill_pos) {
switch (interval->spill_state()) {
case oneDefinitionFound: {
int def_loop_depth = block_of_op_with_id(interval->spill_definition_pos())->loop_depth();
int spill_loop_depth = block_of_op_with_id(spill_pos)->loop_depth();
if (def_loop_depth < spill_loop_depth) {
interval->set_spill_state(storeAtDefinition);
} else {
interval->set_spill_state(oneMoveInserted);
}
break;
}
case oneMoveInserted: {
interval->set_spill_state(storeAtDefinition);
break;
}
case storeAtDefinition:
case startInMemory:
case noOptimization:
case noDefinitionFound:
break;
default:
assert(false, "other states not allowed at this time");
}
}
bool LinearScan::must_store_at_definition(const Interval* i) {
return i->is_split_parent() && i->spill_state() == storeAtDefinition;
}
void LinearScan::eliminate_spill_moves() {
TIME_LINEAR_SCAN(timer_eliminate_spill_moves);
TRACE_LINEAR_SCAN(3, tty->print_cr("***** Eliminating unnecessary spill moves"));
Interval* interval;
Interval* temp_list;
create_unhandled_lists(&interval, &temp_list, must_store_at_definition, NULL);
#ifdef ASSERT
Interval* prev = NULL;
Interval* temp = interval;
while (temp != Interval::end()) {
assert(temp->spill_definition_pos() > 0, "invalid spill definition pos");
if (prev != NULL) {
assert(temp->from() >= prev->from(), "intervals not sorted");
assert(temp->spill_definition_pos() >= prev->spill_definition_pos(), "when intervals are sorted by from, then they must also be sorted by spill_definition_pos");
}
assert(temp->canonical_spill_slot() >= LinearScan::nof_regs, "interval has no spill slot assigned");
assert(temp->spill_definition_pos() >= temp->from(), "invalid order");
assert(temp->spill_definition_pos() <= temp->from() + 2, "only intervals defined once at their start-pos can be optimized");
TRACE_LINEAR_SCAN(4, tty->print_cr("interval %d (from %d to %d) must be stored at %d", temp->reg_num(), temp->from(), temp->to(), temp->spill_definition_pos()));
temp = temp->next();
}
#endif
LIR_InsertionBuffer insertion_buffer;
int num_blocks = block_count();
for (int i = 0; i < num_blocks; i++) {
BlockBegin* block = block_at(i);
LIR_OpList* instructions = block->lir()->instructions_list();
int num_inst = instructions->length();
bool has_new = false;
for (int j = 1; j < num_inst; j++) {
LIR_Op* op = instructions->at(j);
int op_id = op->id();
if (op_id == -1) {
assert(op->code() == lir_move, "only moves can have a op_id of -1");
assert(op->as_Op1() != NULL, "move must be LIR_Op1");
assert(op->as_Op1()->result_opr()->is_virtual(), "LinearScan inserts only moves to virtual registers");
LIR_Op1* op1 = (LIR_Op1*)op;
Interval* interval = interval_at(op1->result_opr()->vreg_number());
if (interval->assigned_reg() >= LinearScan::nof_regs && interval->always_in_memory()) {
TRACE_LINEAR_SCAN(4, tty->print_cr("eliminating move from interval %d to %d", op1->in_opr()->vreg_number(), op1->result_opr()->vreg_number()));
instructions->at_put(j, NULL); // NULL-instructions are deleted by assign_reg_num
}
} else {
assert(interval == Interval::end() || interval->spill_definition_pos() >= op_id, "invalid order");
assert(interval == Interval::end() || (interval->is_split_parent() && interval->spill_state() == storeAtDefinition), "invalid interval");
while (interval != Interval::end() && interval->spill_definition_pos() == op_id) {
if (!has_new) {
insertion_buffer.init(block->lir());
has_new = true;
}
LIR_Opr from_opr = operand_for_interval(interval);
LIR_Opr to_opr = canonical_spill_opr(interval);
assert(from_opr->is_fixed_cpu() || from_opr->is_fixed_fpu(), "from operand must be a register");
assert(to_opr->is_stack(), "to operand must be a stack slot");
insertion_buffer.move(j, from_opr, to_opr);
TRACE_LINEAR_SCAN(4, tty->print_cr("inserting move after definition of interval %d to stack slot %d at op_id %d", interval->reg_num(), interval->canonical_spill_slot() - LinearScan::nof_regs, op_id));
interval = interval->next();
}
}
} // end of instruction iteration
if (has_new) {
block->lir()->append(&insertion_buffer);
}
} // end of block iteration
assert(interval == Interval::end(), "missed an interval");
}
void LinearScan::number_instructions() {
{
TIME_LINEAR_SCAN(timer_do_nothing);
}
TIME_LINEAR_SCAN(timer_number_instructions);
int num_blocks = block_count();
int num_instructions = 0;
int i;
for (i = 0; i < num_blocks; i++) {
num_instructions += block_at(i)->lir()->instructions_list()->length();
}
_lir_ops = LIR_OpArray(num_instructions);
_block_of_op = BlockBeginArray(num_instructions);
int op_id = 0;
int idx = 0;
for (i = 0; i < num_blocks; i++) {
BlockBegin* block = block_at(i);
block->set_first_lir_instruction_id(op_id);
LIR_OpList* instructions = block->lir()->instructions_list();
int num_inst = instructions->length();
for (int j = 0; j < num_inst; j++) {
LIR_Op* op = instructions->at(j);
op->set_id(op_id);
_lir_ops.at_put(idx, op);
_block_of_op.at_put(idx, block);
assert(lir_op_with_id(op_id) == op, "must match");
idx++;
op_id += 2; // numbering of lir_ops by two
}
block->set_last_lir_instruction_id(op_id - 2);
}
assert(idx == num_instructions, "must match");
assert(idx * 2 == op_id, "must match");
_has_call = BitMap(num_instructions); _has_call.clear();
_has_info = BitMap(num_instructions); _has_info.clear();
}
void LinearScan::set_live_gen_kill(Value value, LIR_Op* op, BitMap& live_gen, BitMap& live_kill) {
LIR_Opr opr = value->operand();
Constant* con = value->as_Constant();
assert(!value->type()->is_illegal(), "if this local is used by the interpreter it shouldn't be of indeterminate type");
assert(con == NULL || opr->is_virtual() || opr->is_constant() || opr->is_illegal(), "asumption: Constant instructions have only constant operands");
assert(con != NULL || opr->is_virtual(), "asumption: non-Constant instructions have only virtual operands");
if ((con == NULL || con->is_pinned()) && opr->is_register()) {
assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
int reg = opr->vreg_number();
if (!live_kill.at(reg)) {
live_gen.set_bit(reg);
TRACE_LINEAR_SCAN(4, tty->print_cr(" Setting live_gen for value %c%d, LIR op_id %d, register number %d", value->type()->tchar(), value->id(), op->id(), reg));
}
}
}
void LinearScan::compute_local_live_sets() {
TIME_LINEAR_SCAN(timer_compute_local_live_sets);
int num_blocks = block_count();
int live_size = live_set_size();
bool local_has_fpu_registers = false;
int local_num_calls = 0;
LIR_OpVisitState visitor;
BitMap2D local_interval_in_loop = BitMap2D(_num_virtual_regs, num_loops());
local_interval_in_loop.clear();
for (int i = 0; i < num_blocks; i++) {
BlockBegin* block = block_at(i);
BitMap live_gen(live_size); live_gen.clear();
BitMap live_kill(live_size); live_kill.clear();
if (block->is_set(BlockBegin::exception_entry_flag)) {
for_each_phi_fun(block, phi,
live_kill.set_bit(phi->operand()->vreg_number())
);
}
LIR_OpList* instructions = block->lir()->instructions_list();
int num_inst = instructions->length();
assert(visitor.no_operands(instructions->at(0)), "first operation must always be a label");
for (int j = 1; j < num_inst; j++) {
LIR_Op* op = instructions->at(j);
visitor.visit(op);
if (visitor.has_call()) {
_has_call.set_bit(op->id() >> 1);
local_num_calls++;
}
if (visitor.info_count() > 0) {
_has_info.set_bit(op->id() >> 1);
}
int k, n, reg;
n = visitor.opr_count(LIR_OpVisitState::inputMode);
for (k = 0; k < n; k++) {
LIR_Opr opr = visitor.opr_at(LIR_OpVisitState::inputMode, k);
assert(opr->is_register(), "visitor should only return register operands");
if (opr->is_virtual_register()) {
assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
reg = opr->vreg_number();
if (!live_kill.at(reg)) {
live_gen.set_bit(reg);
TRACE_LINEAR_SCAN(4, tty->print_cr(" Setting live_gen for register %d at instruction %d", reg, op->id()));
}
if (block->loop_index() >= 0) {
local_interval_in_loop.set_bit(reg, block->loop_index());
}
local_has_fpu_registers = local_has_fpu_registers || opr->is_virtual_fpu();
}
#ifdef ASSERT
if (!opr->is_virtual_register() && block != ir()->start()) {
reg = reg_num(opr);
if (is_processed_reg_num(reg)) {
assert(live_kill.at(reg), "using fixed register that is not defined in this block");
}
reg = reg_numHi(opr);
if (is_valid_reg_num(reg) && is_processed_reg_num(reg)) {
assert(live_kill.at(reg), "using fixed register that is not defined in this block");
}
}
#endif
}
n = visitor.info_count();
for (k = 0; k < n; k++) {
CodeEmitInfo* info = visitor.info_at(k);
ValueStack* stack = info->stack();
for_each_state_value(stack, value,
set_live_gen_kill(value, op, live_gen, live_kill)
);
}
n = visitor.opr_count(LIR_OpVisitState::tempMode);
for (k = 0; k < n; k++) {
LIR_Opr opr = visitor.opr_at(LIR_OpVisitState::tempMode, k);
assert(opr->is_register(), "visitor should only return register operands");
if (opr->is_virtual_register()) {
assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
reg = opr->vreg_number();
live_kill.set_bit(reg);
if (block->loop_index() >= 0) {
local_interval_in_loop.set_bit(reg, block->loop_index());
}
local_has_fpu_registers = local_has_fpu_registers || opr->is_virtual_fpu();
}
#ifdef ASSERT
if (!opr->is_virtual_register()) {
reg = reg_num(opr);
if (is_processed_reg_num(reg)) {
live_kill.set_bit(reg_num(opr));
}
reg = reg_numHi(opr);
if (is_valid_reg_num(reg) && is_processed_reg_num(reg)) {
live_kill.set_bit(reg);
}
}
#endif
}
n = visitor.opr_count(LIR_OpVisitState::outputMode);
for (k = 0; k < n; k++) {
LIR_Opr opr = visitor.opr_at(LIR_OpVisitState::outputMode, k);
assert(opr->is_register(), "visitor should only return register operands");
if (opr->is_virtual_register()) {
assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
reg = opr->vreg_number();
live_kill.set_bit(reg);
if (block->loop_index() >= 0) {
local_interval_in_loop.set_bit(reg, block->loop_index());
}
local_has_fpu_registers = local_has_fpu_registers || opr->is_virtual_fpu();
}
#ifdef ASSERT
if (!opr->is_virtual_register()) {
reg = reg_num(opr);
if (is_processed_reg_num(reg)) {
live_kill.set_bit(reg_num(opr));
}
reg = reg_numHi(opr);
if (is_valid_reg_num(reg) && is_processed_reg_num(reg)) {
live_kill.set_bit(reg);
}
}
#endif
}
} // end of instruction iteration
block->set_live_gen (live_gen);
block->set_live_kill(live_kill);
block->set_live_in (BitMap(live_size)); block->live_in().clear();
block->set_live_out (BitMap(live_size)); block->live_out().clear();
TRACE_LINEAR_SCAN(4, tty->print("live_gen B%d ", block->block_id()); print_bitmap(block->live_gen()));
TRACE_LINEAR_SCAN(4, tty->print("live_kill B%d ", block->block_id()); print_bitmap(block->live_kill()));
} // end of block iteration
_has_fpu_registers = local_has_fpu_registers;
compilation()->set_has_fpu_code(local_has_fpu_registers);
_num_calls = local_num_calls;
_interval_in_loop = local_interval_in_loop;
}
void LinearScan::compute_global_live_sets() {
TIME_LINEAR_SCAN(timer_compute_global_live_sets);
int num_blocks = block_count();
bool change_occurred;
bool change_occurred_in_block;
int iteration_count = 0;
BitMap live_out(live_set_size()); live_out.clear(); // scratch set for calculations
do {
change_occurred = false;
for (int i = num_blocks - 1; i >= 0; i--) {
BlockBegin* block = block_at(i);
change_occurred_in_block = false;
int n = block->number_of_sux();
int e = block->number_of_exception_handlers();
if (n + e > 0) {
if (n > 0) {
live_out.set_from(block->sux_at(0)->live_in());
for (int j = 1; j < n; j++) {
live_out.set_union(block->sux_at(j)->live_in());
}
} else {
live_out.clear();
}
for (int j = 0; j < e; j++) {
live_out.set_union(block->exception_handler_at(j)->live_in());
}
if (!block->live_out().is_same(live_out)) {
BitMap temp = block->live_out();
block->set_live_out(live_out);
live_out = temp;
change_occurred = true;
change_occurred_in_block = true;
}
}
if (iteration_count == 0 || change_occurred_in_block) {
BitMap live_in = block->live_in();
live_in.set_from(block->live_out());
live_in.set_difference(block->live_kill());
live_in.set_union(block->live_gen());
}
#ifndef PRODUCT
if (TraceLinearScanLevel >= 4) {
char c = ' ';
if (iteration_count == 0 || change_occurred_in_block) {
c = '*';
}
tty->print("(%d) live_in%c B%d ", iteration_count, c, block->block_id()); print_bitmap(block->live_in());
tty->print("(%d) live_out%c B%d ", iteration_count, c, block->block_id()); print_bitmap(block->live_out());
}
#endif
}
iteration_count++;
if (change_occurred && iteration_count > 50) {
BAILOUT("too many iterations in compute_global_live_sets");
}
} while (change_occurred);
#ifdef ASSERT
for (int i = 0; i < num_blocks; i++) {
BlockBegin* block = block_at(i);
for (int j = 0; j < LIR_OprDesc::vreg_base; j++) {
assert(block->live_in().at(j) == false, "live_in set of fixed register must be empty");
assert(block->live_out().at(j) == false, "live_out set of fixed register must be empty");
assert(block->live_gen().at(j) == false, "live_gen set of fixed register must be empty");
}
}
#endif
BitMap live_in_args(ir()->start()->live_in().size());
live_in_args.clear();
if (!ir()->start()->live_in().is_same(live_in_args)) {
#ifdef ASSERT
tty->print_cr("Error: live_in set of first block must be empty (when this fails, virtual registers are used before they are defined)");
tty->print_cr("affected registers:");
print_bitmap(ir()->start()->live_in());
for (unsigned int i = 0; i < ir()->start()->live_in().size(); i++) {
if (ir()->start()->live_in().at(i)) {
Instruction* instr = gen()->instruction_for_vreg(i);
tty->print_cr("* vreg %d (HIR instruction %c%d)", i, instr == NULL ? ' ' : instr->type()->tchar(), instr == NULL ? 0 : instr->id());
for (int j = 0; j < num_blocks; j++) {
BlockBegin* block = block_at(j);
if (block->live_gen().at(i)) {
tty->print_cr(" used in block B%d", block->block_id());
}
if (block->live_kill().at(i)) {
tty->print_cr(" defined in block B%d", block->block_id());
}
}
}
}
#endif
assert(false, "live_in set of first block must be empty");
bailout("live_in set of first block not empty");
}
}
void LinearScan::add_use(Value value, int from, int to, IntervalUseKind use_kind) {
assert(!value->type()->is_illegal(), "if this value is used by the interpreter it shouldn't be of indeterminate type");
LIR_Opr opr = value->operand();
Constant* con = value->as_Constant();
if ((con == NULL || con->is_pinned()) && opr->is_register()) {
assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
add_use(opr, from, to, use_kind);
}
}
void LinearScan::add_def(LIR_Opr opr, int def_pos, IntervalUseKind use_kind) {
TRACE_LINEAR_SCAN(2, tty->print(" def "); opr->print(tty); tty->print_cr(" def_pos %d (%d)", def_pos, use_kind));
assert(opr->is_register(), "should not be called otherwise");
if (opr->is_virtual_register()) {
assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
add_def(opr->vreg_number(), def_pos, use_kind, opr->type_register());
} else {
int reg = reg_num(opr);
if (is_processed_reg_num(reg)) {
add_def(reg, def_pos, use_kind, opr->type_register());
}
reg = reg_numHi(opr);
if (is_valid_reg_num(reg) && is_processed_reg_num(reg)) {
add_def(reg, def_pos, use_kind, opr->type_register());
}
}
}
void LinearScan::add_use(LIR_Opr opr, int from, int to, IntervalUseKind use_kind) {
TRACE_LINEAR_SCAN(2, tty->print(" use "); opr->print(tty); tty->print_cr(" from %d to %d (%d)", from, to, use_kind));
assert(opr->is_register(), "should not be called otherwise");
if (opr->is_virtual_register()) {
assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
add_use(opr->vreg_number(), from, to, use_kind, opr->type_register());
} else {
int reg = reg_num(opr);
if (is_processed_reg_num(reg)) {
add_use(reg, from, to, use_kind, opr->type_register());
}
reg = reg_numHi(opr);
if (is_valid_reg_num(reg) && is_processed_reg_num(reg)) {
add_use(reg, from, to, use_kind, opr->type_register());
}
}
}
void LinearScan::add_temp(LIR_Opr opr, int temp_pos, IntervalUseKind use_kind) {
TRACE_LINEAR_SCAN(2, tty->print(" temp "); opr->print(tty); tty->print_cr(" temp_pos %d (%d)", temp_pos, use_kind));
assert(opr->is_register(), "should not be called otherwise");
if (opr->is_virtual_register()) {
assert(reg_num(opr) == opr->vreg_number() && !is_valid_reg_num(reg_numHi(opr)), "invalid optimization below");
add_temp(opr->vreg_number(), temp_pos, use_kind, opr->type_register());
} else {
int reg = reg_num(opr);
if (is_processed_reg_num(reg)) {
add_temp(reg, temp_pos, use_kind, opr->type_register());
}
reg = reg_numHi(opr);
if (is_valid_reg_num(reg) && is_processed_reg_num(reg)) {
add_temp(reg, temp_pos, use_kind, opr->type_register());
}
}
}
void LinearScan::add_def(int reg_num, int def_pos, IntervalUseKind use_kind, BasicType type) {
Interval* interval = interval_at(reg_num);
if (interval != NULL) {
assert(interval->reg_num() == reg_num, "wrong interval");
if (type != T_ILLEGAL) {
interval->set_type(type);
}
Range* r = interval->first();
if (r->from() <= def_pos) {
r->set_from(def_pos);
interval->add_use_pos(def_pos, use_kind);
} else {
interval->add_range(def_pos, def_pos + 1);
interval->add_use_pos(def_pos, use_kind);
TRACE_LINEAR_SCAN(2, tty->print_cr("Warning: def of reg %d at %d occurs without use", reg_num, def_pos));
}
} else {
interval = create_interval(reg_num);
if (type != T_ILLEGAL) {
interval->set_type(type);
}
interval->add_range(def_pos, def_pos + 1);
interval->add_use_pos(def_pos, use_kind);
TRACE_LINEAR_SCAN(2, tty->print_cr("Warning: dead value %d at %d in live intervals", reg_num, def_pos));
}
change_spill_definition_pos(interval, def_pos);
if (use_kind == noUse && interval->spill_state() <= startInMemory) {
interval->set_spill_state(startInMemory);
}
}
void LinearScan::add_use(int reg_num, int from, int to, IntervalUseKind use_kind, BasicType type) {
Interval* interval = interval_at(reg_num);
if (interval == NULL) {
interval = create_interval(reg_num);
}
assert(interval->reg_num() == reg_num, "wrong interval");
if (type != T_ILLEGAL) {
interval->set_type(type);
}
interval->add_range(from, to);
interval->add_use_pos(to, use_kind);
}
void LinearScan::add_temp(int reg_num, int temp_pos, IntervalUseKind use_kind, BasicType type) {
Interval* interval = interval_at(reg_num);
if (interval == NULL) {
interval = create_interval(reg_num);
}
assert(interval->reg_num() == reg_num, "wrong interval");
if (type != T_ILLEGAL) {
interval->set_type(type);
}
interval->add_range(temp_pos, temp_pos + 1);
interval->add_use_pos(temp_pos, use_kind);
}
IntervalUseKind LinearScan::use_kind_of_output_operand(LIR_Op* op, LIR_Opr opr) {
if (op->code() == lir_move) {
assert(op->as_Op1() != NULL, "lir_move must be LIR_Op1");
LIR_Op1* move = (LIR_Op1*)op;
LIR_Opr res = move->result_opr();
bool result_in_memory = res->is_virtual() && gen()->is_vreg_flag_set(res->vreg_number(), LIRGenerator::must_start_in_memory);
if (result_in_memory) {
return noUse;
} else if (move->in_opr()->is_stack()) {
return noUse;
} else if (move->in_opr()->is_register() && move->result_opr()->is_register()) {
if (block_of_op_with_id(op->id())->is_set(BlockBegin::osr_entry_flag)) {
return shouldHaveRegister;
}
}
}
if (opr->is_virtual() &&
gen()->is_vreg_flag_set(opr->vreg_number(), LIRGenerator::must_start_in_memory)) {
return noUse;
}
return mustHaveRegister;
}
IntervalUseKind LinearScan::use_kind_of_input_operand(LIR_Op* op, LIR_Opr opr) {
if (op->code() == lir_move) {
assert(op->as_Op1() != NULL, "lir_move must be LIR_Op1");
LIR_Op1* move = (LIR_Op1*)op;
LIR_Opr res = move->result_opr();
bool result_in_memory = res->is_virtual() && gen()->is_vreg_flag_set(res->vreg_number(), LIRGenerator::must_start_in_memory);
if (result_in_memory) {
return mustHaveRegister;
} else if (move->in_opr()->is_register() && move->result_opr()->is_register()) {
if (block_of_op_with_id(op->id())->is_set(BlockBegin::osr_entry_flag)) {
return mustHaveRegister;
}
return shouldHaveRegister;
}
}
#if defined(X86)
if (op->code() == lir_cmove) {
assert(op->result_opr()->is_register(), "result must always be in a register");
return shouldHaveRegister;
}
BasicType opr_type = opr->type_register();
if (opr_type == T_FLOAT || opr_type == T_DOUBLE) {
if ((UseSSE == 1 && opr_type == T_FLOAT) || UseSSE >= 2) {
switch (op->code()) {
case lir_cmp:
case lir_add:
case lir_sub:
case lir_mul:
case lir_div:
{
assert(op->as_Op2() != NULL, "must be LIR_Op2");
LIR_Op2* op2 = (LIR_Op2*)op;
if (op2->in_opr1() != op2->in_opr2() && op2->in_opr2() == opr) {
assert((op2->result_opr()->is_register() || op->code() == lir_cmp) && op2->in_opr1()->is_register(), "cannot mark second operand as stack if others are not in register");
return shouldHaveRegister;
}
}
}
} else {
switch (op->code()) {
case lir_add:
case lir_sub:
case lir_mul:
case lir_div:
{
assert(op->as_Op2() != NULL, "must be LIR_Op2");
LIR_Op2* op2 = (LIR_Op2*)op;
if (op2->in_opr1() != op2->in_opr2() && op2->in_opr2() == opr) {
assert((op2->result_opr()->is_register() || op->code() == lir_cmp) && op2->in_opr1()->is_register(), "cannot mark second operand as stack if others are not in register");
return shouldHaveRegister;
}
}
}
}
} else if (opr_type != T_LONG LP64_ONLY(&& opr_type != T_OBJECT)) {
switch (op->code()) {
case lir_cmp:
case lir_add:
case lir_sub:
case lir_logic_and:
case lir_logic_or:
case lir_logic_xor:
{
assert(op->as_Op2() != NULL, "must be LIR_Op2");
LIR_Op2* op2 = (LIR_Op2*)op;
if (op2->in_opr1() != op2->in_opr2() && op2->in_opr2() == opr) {
assert((op2->result_opr()->is_register() || op->code() == lir_cmp) && op2->in_opr1()->is_register(), "cannot mark second operand as stack if others are not in register");
return shouldHaveRegister;
}
}
}
}
#endif // X86
return mustHaveRegister;
}
void LinearScan::handle_method_arguments(LIR_Op* op) {
if (op->code() == lir_move) {
assert(op->as_Op1() != NULL, "must be LIR_Op1");
LIR_Op1* move = (LIR_Op1*)op;
if (move->in_opr()->is_stack()) {
#ifdef ASSERT
int arg_size = compilation()->method()->arg_size();
LIR_Opr o = move->in_opr();
if (o->is_single_stack()) {
assert(o->single_stack_ix() >= 0 && o->single_stack_ix() < arg_size, "out of range");
} else if (o->is_double_stack()) {
assert(o->double_stack_ix() >= 0 && o->double_stack_ix() < arg_size, "out of range");
} else {
ShouldNotReachHere();
}
assert(move->id() > 0, "invalid id");
assert(block_of_op_with_id(move->id())->number_of_preds() == 0, "move from stack must be in first block");
assert(move->result_opr()->is_virtual(), "result of move must be a virtual register");
TRACE_LINEAR_SCAN(4, tty->print_cr("found move from stack slot %d to vreg %d", o->is_single_stack() ? o->single_stack_ix() : o->double_stack_ix(), reg_num(move->result_opr())));
#endif
Interval* interval = interval_at(reg_num(move->result_opr()));
int stack_slot = LinearScan::nof_regs + (move->in_opr()->is_single_stack() ? move->in_opr()->single_stack_ix() : move->in_opr()->double_stack_ix());
interval->set_canonical_spill_slot(stack_slot);
interval->assign_reg(stack_slot);
}
}
}
void LinearScan::handle_doubleword_moves(LIR_Op* op) {
if (op->code() == lir_move) {
assert(op->as_Op1() != NULL, "must be LIR_Op1");
LIR_Op1* move = (LIR_Op1*)op;
if (move->result_opr()->is_double_cpu() && move->in_opr()->is_pointer()) {
LIR_Address* address = move->in_opr()->as_address_ptr();
if (address != NULL) {
if (address->base()->is_valid()) {
add_temp(address->base(), op->id(), noUse);
}
if (address->index()->is_valid()) {
add_temp(address->index(), op->id(), noUse);
}
}
}
}
}
void LinearScan::add_register_hints(LIR_Op* op) {
switch (op->code()) {
case lir_move: // fall through
case lir_convert: {
assert(op->as_Op1() != NULL, "lir_move, lir_convert must be LIR_Op1");
LIR_Op1* move = (LIR_Op1*)op;
LIR_Opr move_from = move->in_opr();
LIR_Opr move_to = move->result_opr();
if (move_to->is_register() && move_from->is_register()) {
Interval* from = interval_at(reg_num(move_from));
Interval* to = interval_at(reg_num(move_to));
if (from != NULL && to != NULL) {
to->set_register_hint(from);
TRACE_LINEAR_SCAN(4, tty->print_cr("operation at op_id %d: added hint from interval %d to %d", move->id(), from->reg_num(), to->reg_num()));
}
}
break;
}
case lir_cmove: {
assert(op->as_Op2() != NULL, "lir_cmove must be LIR_Op2");
LIR_Op2* cmove = (LIR_Op2*)op;
LIR_Opr move_from = cmove->in_opr1();
LIR_Opr move_to = cmove->result_opr();
if (move_to->is_register() && move_from->is_register()) {
Interval* from = interval_at(reg_num(move_from));
Interval* to = interval_at(reg_num(move_to));
if (from != NULL && to != NULL) {
to->set_register_hint(from);
TRACE_LINEAR_SCAN(4, tty->print_cr("operation at op_id %d: added hint from interval %d to %d", cmove->id(), from->reg_num(), to->reg_num()));
}
}
break;
}
}
}
void LinearScan::build_intervals() {
TIME_LINEAR_SCAN(timer_build_intervals);
_intervals = IntervalList(num_virtual_regs() + 32);
_intervals.at_put_grow(num_virtual_regs() - 1, NULL, NULL);
int num_caller_save_registers = 0;
int caller_save_registers[LinearScan::nof_regs];
int i;
for (i = 0; i < FrameMap::nof_caller_save_cpu_regs(); i++) {
LIR_Opr opr = FrameMap::caller_save_cpu_reg_at(i);
assert(opr->is_valid() && opr->is_register(), "FrameMap should not return invalid operands");
assert(reg_numHi(opr) == -1, "missing addition of range for hi-register");
caller_save_registers[num_caller_save_registers++] = reg_num(opr);
}
if (has_fpu_registers()) {
#ifdef X86
if (UseSSE < 2) {
#endif
for (i = 0; i < FrameMap::nof_caller_save_fpu_regs; i++) {
LIR_Opr opr = FrameMap::caller_save_fpu_reg_at(i);
assert(opr->is_valid() && opr->is_register(), "FrameMap should not return invalid operands");
assert(reg_numHi(opr) == -1, "missing addition of range for hi-register");
caller_save_registers[num_caller_save_registers++] = reg_num(opr);
}
#ifdef X86
}
if (UseSSE > 0) {
for (i = 0; i < FrameMap::nof_caller_save_xmm_regs; i++) {
LIR_Opr opr = FrameMap::caller_save_xmm_reg_at(i);
assert(opr->is_valid() && opr->is_register(), "FrameMap should not return invalid operands");
assert(reg_numHi(opr) == -1, "missing addition of range for hi-register");
caller_save_registers[num_caller_save_registers++] = reg_num(opr);
}
}
#endif
}
assert(num_caller_save_registers <= LinearScan::nof_regs, "out of bounds");
LIR_OpVisitState visitor;
for (i = block_count() - 1; i >= 0; i--) {
BlockBegin* block = block_at(i);
LIR_OpList* instructions = block->lir()->instructions_list();
int block_from = block->first_lir_instruction_id();
int block_to = block->last_lir_instruction_id();
assert(block_from == instructions->at(0)->id(), "must be");
assert(block_to == instructions->at(instructions->length() - 1)->id(), "must be");
BitMap live = block->live_out();
int size = (int)live.size();
for (int number = (int)live.get_next_one_offset(0, size); number < size; number = (int)live.get_next_one_offset(number + 1, size)) {
assert(live.at(number), "should not stop here otherwise");
assert(number >= LIR_OprDesc::vreg_base, "fixed intervals must not be live on block bounds");
TRACE_LINEAR_SCAN(2, tty->print_cr("live in %d to %d", number, block_to + 2));
add_use(number, block_from, block_to + 2, noUse, T_ILLEGAL);
if (block->is_set(BlockBegin::linear_scan_loop_end_flag) &&
block->loop_index() != -1 &&
is_interval_in_loop(number, block->loop_index())) {
interval_at(number)->add_use_pos(block_to + 1, loopEndMarker);
}
}
assert(visitor.no_operands(instructions->at(0)), "first operation must always be a label");
for (int j = instructions->length() - 1; j >= 1; j--) {
LIR_Op* op = instructions->at(j);
int op_id = op->id();
visitor.visit(op);
if (visitor.has_call()) {
for (int k = 0; k < num_caller_save_registers; k++) {
add_temp(caller_save_registers[k], op_id, noUse, T_ILLEGAL);
}
TRACE_LINEAR_SCAN(4, tty->print_cr("operation destroys all caller-save registers"));
}
pd_add_temps(op);
int k, n;
n = visitor.opr_count(LIR_OpVisitState::outputMode);
for (k = 0; k < n; k++) {
LIR_Opr opr = visitor.opr_at(LIR_OpVisitState::outputMode, k);
assert(opr->is_register(), "visitor should only return register operands");
add_def(opr, op_id, use_kind_of_output_operand(op, opr));
}
n = visitor.opr_count(LIR_OpVisitState::tempMode);
for (k = 0; k < n; k++) {
LIR_Opr opr = visitor.opr_at(LIR_OpVisitState::tempMode, k);
assert(opr->is_register(), "visitor should only return register operands");
add_temp(opr, op_id, mustHaveRegister);
}
n = visitor.opr_count(LIR_OpVisitState::inputMode);
for (k = 0; k < n; k++) {
LIR_Opr opr = visitor.opr_at(LIR_OpVisitState::inputMode, k);
assert(opr->is_register(), "visitor should only return register operands");
add_use(opr, block_from, op_id, use_kind_of_input_operand(op, opr));
}
n = visitor.info_count();
for (k = 0; k < n; k++) {
CodeEmitInfo* info = visitor.info_at(k);
ValueStack* stack = info->stack();
for_each_state_value(stack, value,
add_use(value, block_from, op_id + 1, noUse);
);
}
handle_method_arguments(op);
handle_doubleword_moves(op);
add_register_hints(op);
} // end of instruction iteration
} // end of block iteration
for (int n = 0; n < LinearScan::nof_regs; n++) {
Interval* interval = interval_at(n);
if (interval != NULL) {
interval->add_range(0, 1);
}
}
}
int LinearScan::interval_cmp(Interval** a, Interval** b) {
if (*a != NULL) {
if (*b != NULL) {
return (*a)->from() - (*b)->from();
} else {
return -1;
}
} else {
if (*b != NULL) {
return 1;
} else {
return 0;
}
}
}
#ifndef PRODUCT
bool LinearScan::is_sorted(IntervalArray* intervals) {
int from = -1;
int i, j;
for (i = 0; i < intervals->length(); i ++) {
Interval* it = intervals->at(i);
if (it != NULL) {
if (from > it->from()) {
assert(false, "");
return false;
}
from = it->from();
}
}
for (i = 0; i < interval_count(); i++) {
if (interval_at(i) != NULL) {
int num_found = 0;
for (j = 0; j < intervals->length(); j++) {
if (interval_at(i) == intervals->at(j)) {
num_found++;
}
}
assert(num_found == 1, "lists do not contain same intervals");
}
}
for (j = 0; j < intervals->length(); j++) {
int num_found = 0;
for (i = 0; i < interval_count(); i++) {
if (interval_at(i) == intervals->at(j)) {
num_found++;
}
}
assert(num_found == 1, "lists do not contain same intervals");
}
return true;
}
#endif
void LinearScan::add_to_list(Interval** first, Interval** prev, Interval* interval) {
if (*prev != NULL) {
(*prev)->set_next(interval);
} else {
}
}
void LinearScan::create_unhandled_lists(Interval** list1, Interval** list2, bool (is_list1)(const Interval* i), bool (is_list2)(const Interval* i)) {
assert(is_sorted(_sorted_intervals), "interval list is not sorted");
Interval* list1_prev = NULL;
Interval* list2_prev = NULL;
Interval* v;
const int n = _sorted_intervals->length();
for (int i = 0; i < n; i++) {
v = _sorted_intervals->at(i);
if (v == NULL) continue;
if (is_list1(v)) {
add_to_list(list1, &list1_prev, v);
} else if (is_list2 == NULL || is_list2(v)) {
add_to_list(list2, &list2_prev, v);
}
}
if (list1_prev != NULL) list1_prev->set_next(Interval::end());
if (list2_prev != NULL) list2_prev->set_next(Interval::end());
assert(list1_prev == NULL || list1_prev->next() == Interval::end(), "linear list ends not with sentinel");
assert(list2_prev == NULL || list2_prev->next() == Interval::end(), "linear list ends not with sentinel");
}
void LinearScan::sort_intervals_before_allocation() {
TIME_LINEAR_SCAN(timer_sort_intervals_before);
if (_needs_full_resort) {
assert(false, "should never occur");
_sorted_intervals->sort(interval_cmp);
_needs_full_resort = false;
}
IntervalList* unsorted_list = &_intervals;
int unsorted_len = unsorted_list->length();
int sorted_len = 0;
int unsorted_idx;
int sorted_idx = 0;
int sorted_from_max = -1;
for (unsorted_idx = 0; unsorted_idx < unsorted_len; unsorted_idx++) {
if (unsorted_list->at(unsorted_idx) != NULL) {
sorted_len++;
}
}
IntervalArray* sorted_list = new IntervalArray(sorted_len);
for (unsorted_idx = 0; unsorted_idx < unsorted_len; unsorted_idx++) {
Interval* cur_interval = unsorted_list->at(unsorted_idx);
if (cur_interval != NULL) {
int cur_from = cur_interval->from();
if (sorted_from_max <= cur_from) {
sorted_list->at_put(sorted_idx++, cur_interval);
sorted_from_max = cur_interval->from();
} else {
int j;
for (j = sorted_idx - 1; j >= 0 && cur_from < sorted_list->at(j)->from(); j--) {
sorted_list->at_put(j + 1, sorted_list->at(j));
}
sorted_list->at_put(j + 1, cur_interval);
sorted_idx++;
}
}
}
_sorted_intervals = sorted_list;
assert(is_sorted(_sorted_intervals), "intervals unsorted");
}
void LinearScan::sort_intervals_after_allocation() {
TIME_LINEAR_SCAN(timer_sort_intervals_after);
if (_needs_full_resort) {
_sorted_intervals->sort(interval_cmp);
_needs_full_resort = false;
}
IntervalArray* old_list = _sorted_intervals;
IntervalList* new_list = _new_intervals_from_allocation;
int old_len = old_list->length();
int new_len = new_list->length();
if (new_len == 0) {
assert(is_sorted(_sorted_intervals), "intervals unsorted");
return;
}
new_list->sort(interval_cmp);
IntervalArray* combined_list = new IntervalArray(old_len + new_len);
int old_idx = 0;
int new_idx = 0;
while (old_idx + new_idx < old_len + new_len) {
if (new_idx >= new_len || (old_idx < old_len && old_list->at(old_idx)->from() <= new_list->at(new_idx)->from())) {
combined_list->at_put(old_idx + new_idx, old_list->at(old_idx));
old_idx++;
} else {
combined_list->at_put(old_idx + new_idx, new_list->at(new_idx));
new_idx++;
}
}
_sorted_intervals = combined_list;
assert(is_sorted(_sorted_intervals), "intervals unsorted");
}
void LinearScan::allocate_registers() {
TIME_LINEAR_SCAN(timer_allocate_registers);
Interval* precolored_cpu_intervals, *not_precolored_cpu_intervals;
Interval* precolored_fpu_intervals, *not_precolored_fpu_intervals;
create_unhandled_lists(&precolored_cpu_intervals, ¬_precolored_cpu_intervals,
is_precolored_cpu_interval, is_virtual_cpu_interval);
create_unhandled_lists(&precolored_fpu_intervals, ¬_precolored_fpu_intervals,
is_precolored_fpu_interval, is_virtual_fpu_interval);
LinearScanWalker cpu_lsw(this, precolored_cpu_intervals, not_precolored_cpu_intervals);
cpu_lsw.walk();
cpu_lsw.finish_allocation();
if (has_fpu_registers()) {
LinearScanWalker fpu_lsw(this, precolored_fpu_intervals, not_precolored_fpu_intervals);
fpu_lsw.walk();
fpu_lsw.finish_allocation();
}
}
Interval* LinearScan::split_child_at_op_id(Interval* interval, int op_id, LIR_OpVisitState::OprMode mode) {
Interval* result = interval->split_child_at_op_id(op_id, mode);
if (result != NULL) {
return result;
}
assert(false, "must find an interval, but do a clean bailout in product mode");
result = new Interval(LIR_OprDesc::vreg_base);
result->assign_reg(0);
result->set_type(T_INT);
BAILOUT_("LinearScan: interval is NULL", result);
}
Interval* LinearScan::interval_at_block_begin(BlockBegin* block, int reg_num) {
assert(LinearScan::nof_regs <= reg_num && reg_num < num_virtual_regs(), "register number out of bounds");
assert(interval_at(reg_num) != NULL, "no interval found");
return split_child_at_op_id(interval_at(reg_num), block->first_lir_instruction_id(), LIR_OpVisitState::outputMode);
}
Interval* LinearScan::interval_at_block_end(BlockBegin* block, int reg_num) {
assert(LinearScan::nof_regs <= reg_num && reg_num < num_virtual_regs(), "register number out of bounds");
assert(interval_at(reg_num) != NULL, "no interval found");
return split_child_at_op_id(interval_at(reg_num), block->last_lir_instruction_id() + 1, LIR_OpVisitState::outputMode);
}
Interval* LinearScan::interval_at_op_id(int reg_num, int op_id) {
assert(LinearScan::nof_regs <= reg_num && reg_num < num_virtual_regs(), "register number out of bounds");
assert(interval_at(reg_num) != NULL, "no interval found");
return split_child_at_op_id(interval_at(reg_num), op_id, LIR_OpVisitState::inputMode);
}
void LinearScan::resolve_collect_mappings(BlockBegin* from_block, BlockBegin* to_block, MoveResolver &move_resolver) {
DEBUG_ONLY(move_resolver.check_empty());
const int num_regs = num_virtual_regs();
const int size = live_set_size();
const BitMap live_at_edge = to_block->live_in();
for (int r = (int)live_at_edge.get_next_one_offset(0, size); r < size; r = (int)live_at_edge.get_next_one_offset(r + 1, size)) {
assert(r < num_regs, "live information set for not exisiting interval");
assert(from_block->live_out().at(r) && to_block->live_in().at(r), "interval not live at this edge");
Interval* from_interval = interval_at_block_end(from_block, r);
Interval* to_interval = interval_at_block_begin(to_block, r);
if (from_interval != to_interval && (from_interval->assigned_reg() != to_interval->assigned_reg() || from_interval->assigned_regHi() != to_interval->assigned_regHi())) {
move_resolver.add_mapping(from_interval, to_interval);
}
}
}
void LinearScan::resolve_find_insert_pos(BlockBegin* from_block, BlockBegin* to_block, MoveResolver &move_resolver) {
if (from_block->number_of_sux() <= 1) {
TRACE_LINEAR_SCAN(4, tty->print_cr("inserting moves at end of from_block B%d", from_block->block_id()));
LIR_OpList* instructions = from_block->lir()->instructions_list();
LIR_OpBranch* branch = instructions->last()->as_OpBranch();
if (branch != NULL) {
assert(branch->cond() == lir_cond_always, "block does not end with an unconditional jump");
move_resolver.set_insert_position(from_block->lir(), instructions->length() - 2);
} else {
move_resolver.set_insert_position(from_block->lir(), instructions->length() - 1);
}
} else {
TRACE_LINEAR_SCAN(4, tty->print_cr("inserting moves at beginning of to_block B%d", to_block->block_id()));
#ifdef ASSERT
assert(from_block->lir()->instructions_list()->at(0)->as_OpLabel() != NULL, "block does not start with a label");
for (int i = 0; i < to_block->number_of_preds(); i++) {
assert(from_block == to_block->pred_at(i), "all critical edges must be broken");
}
#endif
move_resolver.set_insert_position(to_block->lir(), 0);
}
}
void LinearScan::resolve_data_flow() {
TIME_LINEAR_SCAN(timer_resolve_data_flow);
int num_blocks = block_count();
MoveResolver move_resolver(this);
BitMap block_completed(num_blocks); block_completed.clear();
BitMap already_resolved(num_blocks); already_resolved.clear();
int i;
for (i = 0; i < num_blocks; i++) {
BlockBegin* block = block_at(i);
if (block->number_of_preds() == 1 && block->number_of_sux() == 1 && block->number_of_exception_handlers() == 0) {
LIR_OpList* instructions = block->lir()->instructions_list();
assert(instructions->at(0)->code() == lir_label, "block must start with label");
assert(instructions->last()->code() == lir_branch, "block with successors must end with branch");
assert(instructions->last()->as_OpBranch()->cond() == lir_cond_always, "block with successor must end with unconditional branch");
if (instructions->length() == 2) {
BlockBegin* pred = block->pred_at(0);
BlockBegin* sux = block->sux_at(0);
if (!block_completed.at(pred->linear_scan_number()) && !block_completed.at(sux->linear_scan_number())) {
TRACE_LINEAR_SCAN(3, tty->print_cr("**** optimizing empty block B%d (pred: B%d, sux: B%d)", block->block_id(), pred->block_id(), sux->block_id()));
block_completed.set_bit(block->linear_scan_number());
resolve_collect_mappings(pred, sux, move_resolver);
if (move_resolver.has_mappings()) {
move_resolver.set_insert_position(block->lir(), 0);
move_resolver.resolve_and_append_moves();
}
}
}
}
}
for (i = 0; i < num_blocks; i++) {
if (!block_completed.at(i)) {
BlockBegin* from_block = block_at(i);
already_resolved.set_from(block_completed);
int num_sux = from_block->number_of_sux();
for (int s = 0; s < num_sux; s++) {
BlockBegin* to_block = from_block->sux_at(s);
if (!already_resolved.at(to_block->linear_scan_number())) {
TRACE_LINEAR_SCAN(3, tty->print_cr("**** processing edge between B%d and B%d", from_block->block_id(), to_block->block_id()));
already_resolved.set_bit(to_block->linear_scan_number());
resolve_collect_mappings(from_block, to_block, move_resolver);
if (move_resolver.has_mappings()) {
resolve_find_insert_pos(from_block, to_block, move_resolver);
move_resolver.resolve_and_append_moves();
}
}
}
}
}
}
void LinearScan::resolve_exception_entry(BlockBegin* block, int reg_num, MoveResolver &move_resolver) {
if (interval_at(reg_num) == NULL) {
return;
}
Interval* interval = interval_at_block_begin(block, reg_num);
int reg = interval->assigned_reg();
int regHi = interval->assigned_regHi();
if ((reg < nof_regs && interval->always_in_memory()) ||
(use_fpu_stack_allocation() && reg >= pd_first_fpu_reg && reg <= pd_last_fpu_reg)) {
int from_op_id = block->first_lir_instruction_id();
int to_op_id = from_op_id + 1; // short live range of length 1
assert(interval->from() <= from_op_id && interval->to() >= to_op_id,
"no split allowed between exception entry and first instruction");
if (interval->from() != from_op_id) {
interval = interval->split(from_op_id);
interval->assign_reg(reg, regHi);
append_interval(interval);
} else {
_needs_full_resort = true;
}
assert(interval->from() == from_op_id, "must be true now");
Interval* spilled_part = interval;
if (interval->to() != to_op_id) {
spilled_part = interval->split_from_start(to_op_id);
append_interval(spilled_part);
move_resolver.add_mapping(spilled_part, interval);
}
assign_spill_slot(spilled_part);
assert(spilled_part->from() == from_op_id && spilled_part->to() == to_op_id, "just checking");
}
}
void LinearScan::resolve_exception_entry(BlockBegin* block, MoveResolver &move_resolver) {
assert(block->is_set(BlockBegin::exception_entry_flag), "should not call otherwise");
DEBUG_ONLY(move_resolver.check_empty());
int size = live_set_size();
for (int r = (int)block->live_in().get_next_one_offset(0, size); r < size; r = (int)block->live_in().get_next_one_offset(r + 1, size)) {
resolve_exception_entry(block, r, move_resolver);
}
for_each_phi_fun(block, phi,
resolve_exception_entry(block, phi->operand()->vreg_number(), move_resolver)
);
if (move_resolver.has_mappings()) {
move_resolver.set_insert_position(block->lir(), 0);
move_resolver.resolve_and_append_moves();
}
}
void LinearScan::resolve_exception_edge(XHandler* handler, int throwing_op_id, int reg_num, Phi* phi, MoveResolver &move_resolver) {
if (interval_at(reg_num) == NULL) {
return;
}
BlockBegin* to_block = handler->entry_block();
Interval* to_interval = interval_at_block_begin(to_block, reg_num);
if (phi != NULL) {
Value from_value = phi->operand_at(handler->phi_operand());
move_resolver.set_multiple_reads_allowed();
Constant* con = from_value->as_Constant();
if (con != NULL && !con->is_pinned()) {
move_resolver.add_mapping(LIR_OprFact::value_type(con->type()), to_interval);
} else {
Interval* from_interval = interval_at_op_id(from_value->operand()->vreg_number(), throwing_op_id);
move_resolver.add_mapping(from_interval, to_interval);
}
} else {
Interval* from_interval = interval_at_op_id(reg_num, throwing_op_id);
if (from_interval != to_interval) {
if (!from_interval->always_in_memory() || from_interval->canonical_spill_slot() != to_interval->assigned_reg()) {
move_resolver.add_mapping(from_interval, to_interval);
}
}
}
}
void LinearScan::resolve_exception_edge(XHandler* handler, int throwing_op_id, MoveResolver &move_resolver) {
TRACE_LINEAR_SCAN(4, tty->print_cr("resolving exception handler B%d: throwing_op_id=%d", handler->entry_block()->block_id(), throwing_op_id));
DEBUG_ONLY(move_resolver.check_empty());
assert(handler->lir_op_id() == -1, "already processed this xhandler");
DEBUG_ONLY(handler->set_lir_op_id(throwing_op_id));
assert(handler->entry_code() == NULL, "code already present");
BlockBegin* block = handler->entry_block();
int size = live_set_size();
for (int r = (int)block->live_in().get_next_one_offset(0, size); r < size; r = (int)block->live_in().get_next_one_offset(r + 1, size)) {
resolve_exception_edge(handler, throwing_op_id, r, NULL, move_resolver);
}
for_each_phi_fun(block, phi,
resolve_exception_edge(handler, throwing_op_id, phi->operand()->vreg_number(), phi, move_resolver)
);
if (move_resolver.has_mappings()) {
LIR_List* entry_code = new LIR_List(compilation());
move_resolver.set_insert_position(entry_code, 0);
move_resolver.resolve_and_append_moves();
entry_code->jump(handler->entry_block());
handler->set_entry_code(entry_code);
}
}
void LinearScan::resolve_exception_handlers() {
MoveResolver move_resolver(this);
LIR_OpVisitState visitor;
int num_blocks = block_count();
int i;
for (i = 0; i < num_blocks; i++) {
BlockBegin* block = block_at(i);
if (block->is_set(BlockBegin::exception_entry_flag)) {
resolve_exception_entry(block, move_resolver);
}
}
for (i = 0; i < num_blocks; i++) {
BlockBegin* block = block_at(i);
LIR_List* ops = block->lir();
int num_ops = ops->length();
assert(visitor.no_operands(ops->at(0)), "first operation must always be a label");
for (int j = 1; j < num_ops; j++) {
LIR_Op* op = ops->at(j);
int op_id = op->id();
if (op_id != -1 && has_info(op_id)) {
visitor.visit(op);
assert(visitor.info_count() > 0, "should not visit otherwise");
XHandlers* xhandlers = visitor.all_xhandler();
int n = xhandlers->length();
for (int k = 0; k < n; k++) {
resolve_exception_edge(xhandlers->handler_at(k), op_id, move_resolver);
}
#ifdef ASSERT
} else {
visitor.visit(op);
assert(visitor.all_xhandler()->length() == 0, "missed exception handler");
#endif
}
}
}
}
VMReg LinearScan::vm_reg_for_interval(Interval* interval) {
VMReg reg = interval->cached_vm_reg();
if (!reg->is_valid() ) {
reg = vm_reg_for_operand(operand_for_interval(interval));
interval->set_cached_vm_reg(reg);
}
assert(reg == vm_reg_for_operand(operand_for_interval(interval)), "wrong cached value");
return reg;
}
VMReg LinearScan::vm_reg_for_operand(LIR_Opr opr) {
assert(opr->is_oop(), "currently only implemented for oop operands");
return frame_map()->regname(opr);
}
LIR_Opr LinearScan::operand_for_interval(Interval* interval) {
LIR_Opr opr = interval->cached_opr();
if (opr->is_illegal()) {
opr = calc_operand_for_interval(interval);
interval->set_cached_opr(opr);
}
assert(opr == calc_operand_for_interval(interval), "wrong cached value");
return opr;
}
LIR_Opr LinearScan::calc_operand_for_interval(const Interval* interval) {
int assigned_reg = interval->assigned_reg();
BasicType type = interval->type();
if (assigned_reg >= nof_regs) {
assert(interval->assigned_regHi() == any_reg, "must not have hi register");
return LIR_OprFact::stack(assigned_reg - nof_regs, type);
} else {
switch (type) {
case T_OBJECT: {
assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register");
assert(interval->assigned_regHi() == any_reg, "must not have hi register");
return LIR_OprFact::single_cpu_oop(assigned_reg);
}
case T_ADDRESS: {
assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register");
assert(interval->assigned_regHi() == any_reg, "must not have hi register");
return LIR_OprFact::single_cpu_address(assigned_reg);
}
case T_METADATA: {
assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register");
assert(interval->assigned_regHi() == any_reg, "must not have hi register");
return LIR_OprFact::single_cpu_metadata(assigned_reg);
}
#ifdef __SOFTFP__
case T_FLOAT: // fall through
#endif // __SOFTFP__
case T_INT: {
assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register");
assert(interval->assigned_regHi() == any_reg, "must not have hi register");
return LIR_OprFact::single_cpu(assigned_reg);
}
#ifdef __SOFTFP__
case T_DOUBLE: // fall through
#endif // __SOFTFP__
case T_LONG: {
int assigned_regHi = interval->assigned_regHi();
assert(assigned_reg >= pd_first_cpu_reg && assigned_reg <= pd_last_cpu_reg, "no cpu register");
assert(num_physical_regs(T_LONG) == 1 ||
(assigned_regHi >= pd_first_cpu_reg && assigned_regHi <= pd_last_cpu_reg), "no cpu register");
assert(assigned_reg != assigned_regHi, "invalid allocation");
assert(num_physical_regs(T_LONG) == 1 || assigned_reg < assigned_regHi,
"register numbers must be sorted (ensure that e.g. a move from eax,ebx to ebx,eax can not occur)");
assert((assigned_regHi != any_reg) ^ (num_physical_regs(T_LONG) == 1), "must be match");
if (requires_adjacent_regs(T_LONG)) {
assert(assigned_reg % 2 == 0 && assigned_reg + 1 == assigned_regHi, "must be sequential and even");
}
#ifdef _LP64
return LIR_OprFact::double_cpu(assigned_reg, assigned_reg);
#else
#if defined(SPARC) || defined(PPC)
return LIR_OprFact::double_cpu(assigned_regHi, assigned_reg);
#else
return LIR_OprFact::double_cpu(assigned_reg, assigned_regHi);
#endif // SPARC
#endif // LP64
}
#ifndef __SOFTFP__
case T_FLOAT: {
#ifdef X86
if (UseSSE >= 1) {
assert(assigned_reg >= pd_first_xmm_reg && assigned_reg <= pd_last_xmm_reg, "no xmm register");
assert(interval->assigned_regHi() == any_reg, "must not have hi register");
return LIR_OprFact::single_xmm(assigned_reg - pd_first_xmm_reg);
}
#endif
assert(assigned_reg >= pd_first_fpu_reg && assigned_reg <= pd_last_fpu_reg, "no fpu register");
assert(interval->assigned_regHi() == any_reg, "must not have hi register");
return LIR_OprFact::single_fpu(assigned_reg - pd_first_fpu_reg);
}
case T_DOUBLE: {
#ifdef X86
if (UseSSE >= 2) {
assert(assigned_reg >= pd_first_xmm_reg && assigned_reg <= pd_last_xmm_reg, "no xmm register");
assert(interval->assigned_regHi() == any_reg, "must not have hi register (double xmm values are stored in one register)");
return LIR_OprFact::double_xmm(assigned_reg - pd_first_xmm_reg);
}
#endif
#ifdef SPARC
assert(assigned_reg >= pd_first_fpu_reg && assigned_reg <= pd_last_fpu_reg, "no fpu register");
assert(interval->assigned_regHi() >= pd_first_fpu_reg && interval->assigned_regHi() <= pd_last_fpu_reg, "no fpu register");
assert(assigned_reg % 2 == 0 && assigned_reg + 1 == interval->assigned_regHi(), "must be sequential and even");
LIR_Opr result = LIR_OprFact::double_fpu(interval->assigned_regHi() - pd_first_fpu_reg, assigned_reg - pd_first_fpu_reg);
#elif defined(ARM32)
assert(assigned_reg >= pd_first_fpu_reg && assigned_reg <= pd_last_fpu_reg, "no fpu register");
assert(interval->assigned_regHi() >= pd_first_fpu_reg && interval->assigned_regHi() <= pd_last_fpu_reg, "no fpu register");
assert(assigned_reg % 2 == 0 && assigned_reg + 1 == interval->assigned_regHi(), "must be sequential and even");
LIR_Opr result = LIR_OprFact::double_fpu(assigned_reg - pd_first_fpu_reg, interval->assigned_regHi() - pd_first_fpu_reg);
#else
assert(assigned_reg >= pd_first_fpu_reg && assigned_reg <= pd_last_fpu_reg, "no fpu register");
assert(interval->assigned_regHi() == any_reg, "must not have hi register (double fpu values are stored in one register on Intel)");
LIR_Opr result = LIR_OprFact::double_fpu(assigned_reg - pd_first_fpu_reg);
#endif
return result;
}
#endif // __SOFTFP__
default: {
ShouldNotReachHere();
return LIR_OprFact::illegalOpr;
}
}
}
}
LIR_Opr LinearScan::canonical_spill_opr(Interval* interval) {
assert(interval->canonical_spill_slot() >= nof_regs, "canonical spill slot not set");
return LIR_OprFact::stack(interval->canonical_spill_slot() - nof_regs, interval->type());
}
LIR_Opr LinearScan::color_lir_opr(LIR_Opr opr, int op_id, LIR_OpVisitState::OprMode mode) {
assert(opr->is_virtual(), "should not call this otherwise");
Interval* interval = interval_at(opr->vreg_number());
assert(interval != NULL, "interval must exist");
if (op_id != -1) {
#ifdef ASSERT
BlockBegin* block = block_of_op_with_id(op_id);
if (block->number_of_sux() <= 1 && op_id == block->last_lir_instruction_id()) {
LIR_OpBranch* branch = block->lir()->instructions_list()->last()->as_OpBranch();
if (branch != NULL) {
if (block->live_out().at(opr->vreg_number())) {
assert(branch->cond() == lir_cond_always, "block does not end with an unconditional jump");
assert(false, "can't get split child for the last branch of a block because the information would be incorrect (moves are inserted before the branch in resolve_data_flow)");
}
}
}
#endif
interval = split_child_at_op_id(interval, op_id, mode);
}
LIR_Opr res = operand_for_interval(interval);
#if defined(X86) || defined(AARCH64)
if (res->is_fpu_register()) {
if (opr->is_last_use() || op_id == interval->to() || (op_id != -1 && interval->has_hole_between(op_id, op_id + 1))) {
assert(op_id == -1 || !is_block_begin(op_id), "holes at begin of block may also result from control flow");
res = res->make_last_use();
}
}
#endif
assert(!gen()->is_vreg_flag_set(opr->vreg_number(), LIRGenerator::callee_saved) || !FrameMap::is_caller_save_register(res), "bad allocation");
return res;
}
#ifdef ASSERT
void assert_no_register_values(GrowableArray<ScopeValue*>* values) {
if (values == NULL) {
return;
}
for (int i = 0; i < values->length(); i++) {
ScopeValue* value = values->at(i);
if (value->is_location()) {
Location location = ((LocationValue*)value)->location();
assert(location.where() == Location::on_stack, "value is in register");
}
}
}
void assert_no_register_values(GrowableArray<MonitorValue*>* values) {
if (values == NULL) {
return;
}
for (int i = 0; i < values->length(); i++) {
MonitorValue* value = values->at(i);
if (value->owner()->is_location()) {
Location location = ((LocationValue*)value->owner())->location();
assert(location.where() == Location::on_stack, "owner is in register");
}
assert(value->basic_lock().where() == Location::on_stack, "basic_lock is in register");
}
}
void assert_equal(Location l1, Location l2) {
assert(l1.where() == l2.where() && l1.type() == l2.type() && l1.offset() == l2.offset(), "");
}
void assert_equal(ScopeValue* v1, ScopeValue* v2) {
if (v1->is_location()) {
assert(v2->is_location(), "");
assert_equal(((LocationValue*)v1)->location(), ((LocationValue*)v2)->location());
} else if (v1->is_constant_int()) {
assert(v2->is_constant_int(), "");
assert(((ConstantIntValue*)v1)->value() == ((ConstantIntValue*)v2)->value(), "");
} else if (v1->is_constant_double()) {
assert(v2->is_constant_double(), "");
assert(((ConstantDoubleValue*)v1)->value() == ((ConstantDoubleValue*)v2)->value(), "");
} else if (v1->is_constant_long()) {
assert(v2->is_constant_long(), "");
assert(((ConstantLongValue*)v1)->value() == ((ConstantLongValue*)v2)->value(), "");
} else if (v1->is_constant_oop()) {
assert(v2->is_constant_oop(), "");
assert(((ConstantOopWriteValue*)v1)->value() == ((ConstantOopWriteValue*)v2)->value(), "");
} else {
ShouldNotReachHere();
}
}
void assert_equal(MonitorValue* m1, MonitorValue* m2) {
assert_equal(m1->owner(), m2->owner());
assert_equal(m1->basic_lock(), m2->basic_lock());
}
void assert_equal(IRScopeDebugInfo* d1, IRScopeDebugInfo* d2) {
assert(d1->scope() == d2->scope(), "not equal");
assert(d1->bci() == d2->bci(), "not equal");
if (d1->locals() != NULL) {
assert(d1->locals() != NULL && d2->locals() != NULL, "not equal");
assert(d1->locals()->length() == d2->locals()->length(), "not equal");
for (int i = 0; i < d1->locals()->length(); i++) {
assert_equal(d1->locals()->at(i), d2->locals()->at(i));
}
} else {
assert(d1->locals() == NULL && d2->locals() == NULL, "not equal");
}
if (d1->expressions() != NULL) {
assert(d1->expressions() != NULL && d2->expressions() != NULL, "not equal");
assert(d1->expressions()->length() == d2->expressions()->length(), "not equal");
for (int i = 0; i < d1->expressions()->length(); i++) {
assert_equal(d1->expressions()->at(i), d2->expressions()->at(i));
}
} else {
assert(d1->expressions() == NULL && d2->expressions() == NULL, "not equal");
}
if (d1->monitors() != NULL) {
assert(d1->monitors() != NULL && d2->monitors() != NULL, "not equal");
assert(d1->monitors()->length() == d2->monitors()->length(), "not equal");
for (int i = 0; i < d1->monitors()->length(); i++) {
assert_equal(d1->monitors()->at(i), d2->monitors()->at(i));
}
} else {
assert(d1->monitors() == NULL && d2->monitors() == NULL, "not equal");
}
if (d1->caller() != NULL) {
assert(d1->caller() != NULL && d2->caller() != NULL, "not equal");
assert_equal(d1->caller(), d2->caller());
} else {
assert(d1->caller() == NULL && d2->caller() == NULL, "not equal");
}
}
void check_stack_depth(CodeEmitInfo* info, int stack_end) {
if (info->stack()->bci() != SynchronizationEntryBCI && !info->scope()->method()->is_native()) {
Bytecodes::Code code = info->scope()->method()->java_code_at_bci(info->stack()->bci());
switch (code) {
case Bytecodes::_ifnull : // fall through
case Bytecodes::_ifnonnull : // fall through
case Bytecodes::_ifeq : // fall through
case Bytecodes::_ifne : // fall through
case Bytecodes::_iflt : // fall through
case Bytecodes::_ifge : // fall through
case Bytecodes::_ifgt : // fall through
case Bytecodes::_ifle : // fall through
case Bytecodes::_if_icmpeq : // fall through
case Bytecodes::_if_icmpne : // fall through
case Bytecodes::_if_icmplt : // fall through
case Bytecodes::_if_icmpge : // fall through
case Bytecodes::_if_icmpgt : // fall through
case Bytecodes::_if_icmple : // fall through
case Bytecodes::_if_acmpeq : // fall through
case Bytecodes::_if_acmpne :
assert(stack_end >= -Bytecodes::depth(code), "must have non-empty expression stack at if bytecode");
break;
}
}
}
#endif // ASSERT
IntervalWalker* LinearScan::init_compute_oop_maps() {
Interval* oop_intervals;
Interval* non_oop_intervals;
create_unhandled_lists(&oop_intervals, &non_oop_intervals, is_oop_interval, NULL);
non_oop_intervals = new Interval(any_reg);
non_oop_intervals->add_range(max_jint - 2, max_jint - 1);
return new IntervalWalker(this, oop_intervals, non_oop_intervals);
}
OopMap* LinearScan::compute_oop_map(IntervalWalker* iw, LIR_Op* op, CodeEmitInfo* info, bool is_call_site) {
TRACE_LINEAR_SCAN(3, tty->print_cr("creating oop map at op_id %d", op->id()));
iw->walk_before(op->id());
int frame_size = frame_map()->framesize();
int arg_count = frame_map()->oop_map_arg_count();
OopMap* map = new OopMap(frame_size, arg_count);
for (Interval* interval = iw->active_first(fixedKind); interval != Interval::end(); interval = interval->next()) {
int assigned_reg = interval->assigned_reg();
assert(interval->current_from() <= op->id() && op->id() <= interval->current_to(), "interval should not be active otherwise");
assert(interval->assigned_regHi() == any_reg, "oop must be single word");
assert(interval->reg_num() >= LIR_OprDesc::vreg_base, "fixed interval found");
if (op->is_patching() || op->id() < interval->current_to()) {
assert(!is_call_site || assigned_reg >= nof_regs || !is_caller_save(assigned_reg), "interval is in a caller-save register at a call -> register will be overwritten");
VMReg name = vm_reg_for_interval(interval);
set_oop(map, name);
if (interval->always_in_memory() &&
op->id() > interval->spill_definition_pos() &&
interval->assigned_reg() != interval->canonical_spill_slot()) {
assert(interval->spill_definition_pos() > 0, "position not set correctly");
assert(interval->canonical_spill_slot() >= LinearScan::nof_regs, "no spill slot assigned");
assert(interval->assigned_reg() < LinearScan::nof_regs, "interval is on stack, so stack slot is registered twice");
set_oop(map, frame_map()->slot_regname(interval->canonical_spill_slot() - LinearScan::nof_regs));
}
}
}
assert(info->stack() != NULL, "CodeEmitInfo must always have a stack");
int locks_count = info->stack()->total_locks_size();
for (int i = 0; i < locks_count; i++) {
set_oop(map, frame_map()->monitor_object_regname(i));
}
return map;
}
void LinearScan::compute_oop_map(IntervalWalker* iw, const LIR_OpVisitState &visitor, LIR_Op* op) {
assert(visitor.info_count() > 0, "no oop map needed");
CodeEmitInfo* first_info = visitor.info_at(0);
OopMap* first_oop_map = compute_oop_map(iw, op, first_info, visitor.has_call());
for (int i = 0; i < visitor.info_count(); i++) {
CodeEmitInfo* info = visitor.info_at(i);
OopMap* oop_map = first_oop_map;
_compilation->update_interpreter_frame_size(info->interpreter_frame_size());
if (info->stack()->locks_size() != first_info->stack()->locks_size()) {
oop_map = compute_oop_map(iw, op, info, visitor.has_call());
}
if (info->_oop_map == NULL) {
info->_oop_map = oop_map;
} else {
assert(info->_oop_map == oop_map, "same CodeEmitInfo used for multiple LIR instructions");
}
}
}
ConstantOopWriteValue* LinearScan::_oop_null_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantOopWriteValue(NULL);
ConstantIntValue* LinearScan::_int_m1_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(-1);
ConstantIntValue* LinearScan::_int_0_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(0);
ConstantIntValue* LinearScan::_int_1_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(1);
ConstantIntValue* LinearScan::_int_2_scope_value = new (ResourceObj::C_HEAP, mtCompiler) ConstantIntValue(2);
LocationValue* _illegal_value = new (ResourceObj::C_HEAP, mtCompiler) LocationValue(Location());
void LinearScan::init_compute_debug_info() {
_scope_value_cache = ScopeValueArray((LinearScan::nof_cpu_regs + frame_map()->argcount() + max_spills()) * 2, NULL);
}
MonitorValue* LinearScan::location_for_monitor_index(int monitor_index) {
Location loc;
if (!frame_map()->location_for_monitor_object(monitor_index, &loc)) {
bailout("too large frame");
}
ScopeValue* object_scope_value = new LocationValue(loc);
if (!frame_map()->location_for_monitor_lock(monitor_index, &loc)) {
bailout("too large frame");
}
return new MonitorValue(object_scope_value, loc);
}
LocationValue* LinearScan::location_for_name(int name, Location::Type loc_type) {
Location loc;
if (!frame_map()->locations_for_slot(name, loc_type, &loc)) {
bailout("too large frame");
}
return new LocationValue(loc);
}
int LinearScan::append_scope_value_for_constant(LIR_Opr opr, GrowableArray<ScopeValue*>* scope_values) {
assert(opr->is_constant(), "should not be called otherwise");
LIR_Const* c = opr->as_constant_ptr();
BasicType t = c->type();
switch (t) {
case T_OBJECT: {
jobject value = c->as_jobject();
if (value == NULL) {
scope_values->append(_oop_null_scope_value);
} else {
scope_values->append(new ConstantOopWriteValue(c->as_jobject()));
}
return 1;
}
case T_INT: // fall through
case T_FLOAT: {
int value = c->as_jint_bits();
switch (value) {
case -1: scope_values->append(_int_m1_scope_value); break;
case 0: scope_values->append(_int_0_scope_value); break;
case 1: scope_values->append(_int_1_scope_value); break;
case 2: scope_values->append(_int_2_scope_value); break;
default: scope_values->append(new ConstantIntValue(c->as_jint_bits())); break;
}
return 1;
}
case T_LONG: // fall through
case T_DOUBLE: {
#ifdef _LP64
scope_values->append(_int_0_scope_value);
scope_values->append(new ConstantLongValue(c->as_jlong_bits()));
#else
if (hi_word_offset_in_bytes > lo_word_offset_in_bytes) {
scope_values->append(new ConstantIntValue(c->as_jint_hi_bits()));
scope_values->append(new ConstantIntValue(c->as_jint_lo_bits()));
} else {
scope_values->append(new ConstantIntValue(c->as_jint_lo_bits()));
scope_values->append(new ConstantIntValue(c->as_jint_hi_bits()));
}
#endif
return 2;
}
case T_ADDRESS: {
#ifdef _LP64
scope_values->append(new ConstantLongValue(c->as_jint()));
#else
scope_values->append(new ConstantIntValue(c->as_jint()));
#endif
return 1;
}
default:
ShouldNotReachHere();
return -1;
}
}
int LinearScan::append_scope_value_for_operand(LIR_Opr opr, GrowableArray<ScopeValue*>* scope_values) {
if (opr->is_single_stack()) {
int stack_idx = opr->single_stack_ix();
bool is_oop = opr->is_oop_register();
int cache_idx = (stack_idx + LinearScan::nof_cpu_regs) * 2 + (is_oop ? 1 : 0);
ScopeValue* sv = _scope_value_cache.at(cache_idx);
if (sv == NULL) {
Location::Type loc_type = is_oop ? Location::oop : Location::normal;
sv = location_for_name(stack_idx, loc_type);
_scope_value_cache.at_put(cache_idx, sv);
}
DEBUG_ONLY(assert_equal(sv, location_for_name(stack_idx, is_oop ? Location::oop : Location::normal)));
scope_values->append(sv);
return 1;
} else if (opr->is_single_cpu()) {
bool is_oop = opr->is_oop_register();
int cache_idx = opr->cpu_regnr() * 2 + (is_oop ? 1 : 0);
Location::Type int_loc_type = NOT_LP64(Location::normal) LP64_ONLY(Location::int_in_long);
ScopeValue* sv = _scope_value_cache.at(cache_idx);
if (sv == NULL) {
Location::Type loc_type = is_oop ? Location::oop : int_loc_type;
VMReg rname = frame_map()->regname(opr);
sv = new LocationValue(Location::new_reg_loc(loc_type, rname));
_scope_value_cache.at_put(cache_idx, sv);
}
DEBUG_ONLY(assert_equal(sv, new LocationValue(Location::new_reg_loc(is_oop ? Location::oop : int_loc_type, frame_map()->regname(opr)))));
scope_values->append(sv);
return 1;
#ifdef X86
} else if (opr->is_single_xmm()) {
VMReg rname = opr->as_xmm_float_reg()->as_VMReg();
LocationValue* sv = new LocationValue(Location::new_reg_loc(Location::normal, rname));
scope_values->append(sv);
return 1;
#endif
} else if (opr->is_single_fpu()) {
#ifdef X86
assert(use_fpu_stack_allocation(), "should not have float stack values without fpu stack allocation (all floats must be SSE2)");
assert(_fpu_stack_allocator != NULL, "must be present");
opr = _fpu_stack_allocator->to_fpu_stack(opr);
#endif
Location::Type loc_type = float_saved_as_double ? Location::float_in_dbl : Location::normal;
VMReg rname = frame_map()->fpu_regname(opr->fpu_regnr());
#ifndef __SOFTFP__
#ifndef VM_LITTLE_ENDIAN
if (! float_saved_as_double) {
VMReg next = VMRegImpl::as_VMReg(1+rname->value());
if (next->is_reg() &&
(next->as_FloatRegister() == rname->as_FloatRegister())) {
rname = next; // VMReg for the low bits, e.g. the real VMReg for the float
}
}
#endif
#endif
LocationValue* sv = new LocationValue(Location::new_reg_loc(loc_type, rname));
scope_values->append(sv);
return 1;
} else {
ScopeValue* first;
ScopeValue* second;
if (opr->is_double_stack()) {
#ifdef _LP64
Location loc1;
Location::Type loc_type = opr->type() == T_LONG ? Location::lng : Location::dbl;
if (!frame_map()->locations_for_slot(opr->double_stack_ix(), loc_type, &loc1, NULL)) {
bailout("too large frame");
}
first = new LocationValue(loc1);
second = _int_0_scope_value;
#else
Location loc1, loc2;
if (!frame_map()->locations_for_slot(opr->double_stack_ix(), Location::normal, &loc1, &loc2)) {
bailout("too large frame");
}
first = new LocationValue(loc1);
second = new LocationValue(loc2);
#endif // _LP64
} else if (opr->is_double_cpu()) {
#ifdef _LP64
VMReg rname_first = opr->as_register_lo()->as_VMReg();
first = new LocationValue(Location::new_reg_loc(Location::lng, rname_first));
second = _int_0_scope_value;
#else
VMReg rname_first = opr->as_register_lo()->as_VMReg();
VMReg rname_second = opr->as_register_hi()->as_VMReg();
if (hi_word_offset_in_bytes < lo_word_offset_in_bytes) {
VMReg tmp = rname_first;
rname_first = rname_second;
rname_second = tmp;
}
first = new LocationValue(Location::new_reg_loc(Location::normal, rname_first));
second = new LocationValue(Location::new_reg_loc(Location::normal, rname_second));
#endif //_LP64
#ifdef X86
} else if (opr->is_double_xmm()) {
assert(opr->fpu_regnrLo() == opr->fpu_regnrHi(), "assumed in calculation");
VMReg rname_first = opr->as_xmm_double_reg()->as_VMReg();
# ifdef _LP64
first = new LocationValue(Location::new_reg_loc(Location::dbl, rname_first));
second = _int_0_scope_value;
# else
first = new LocationValue(Location::new_reg_loc(Location::normal, rname_first));
if (true) {
VMReg rname_second = rname_first->next();
second = new LocationValue(Location::new_reg_loc(Location::normal, rname_second));
}
# endif
#endif
} else if (opr->is_double_fpu()) {
#ifdef X86
assert(use_fpu_stack_allocation(), "should not have float stack values without fpu stack allocation (all floats must be SSE2)");
assert(_fpu_stack_allocator != NULL, "must be present");
opr = _fpu_stack_allocator->to_fpu_stack(opr);
assert(opr->fpu_regnrLo() == opr->fpu_regnrHi(), "assumed in calculation (only fpu_regnrLo is used)");
#endif
#ifdef SPARC
assert(opr->fpu_regnrLo() == opr->fpu_regnrHi() + 1, "assumed in calculation (only fpu_regnrHi is used)");
#endif
#ifdef ARM32
assert(opr->fpu_regnrHi() == opr->fpu_regnrLo() + 1, "assumed in calculation (only fpu_regnrLo is used)");
#endif
#ifdef PPC
assert(opr->fpu_regnrLo() == opr->fpu_regnrHi(), "assumed in calculation (only fpu_regnrHi is used)");
#endif
#ifdef VM_LITTLE_ENDIAN
VMReg rname_first = frame_map()->fpu_regname(opr->fpu_regnrLo());
#else
VMReg rname_first = frame_map()->fpu_regname(opr->fpu_regnrHi());
#endif
#ifdef _LP64
first = new LocationValue(Location::new_reg_loc(Location::dbl, rname_first));
second = _int_0_scope_value;
#else
first = new LocationValue(Location::new_reg_loc(Location::normal, rname_first));
if (true) {
VMReg rname_second = rname_first->next();
second = new LocationValue(Location::new_reg_loc(Location::normal, rname_second));
}
#endif
} else {
ShouldNotReachHere();
first = NULL;
second = NULL;
}
assert(first != NULL && second != NULL, "must be set");
scope_values->append(second);
scope_values->append(first);
return 2;
}
}
int LinearScan::append_scope_value(int op_id, Value value, GrowableArray<ScopeValue*>* scope_values) {
if (value != NULL) {
LIR_Opr opr = value->operand();
Constant* con = value->as_Constant();
assert(con == NULL || opr->is_virtual() || opr->is_constant() || opr->is_illegal(), "asumption: Constant instructions have only constant operands (or illegal if constant is optimized away)");
assert(con != NULL || opr->is_virtual(), "asumption: non-Constant instructions have only virtual operands");
if (con != NULL && !con->is_pinned() && !opr->is_constant()) {
opr = LIR_OprFact::value_type(con->type());
}
assert(opr->is_virtual() || opr->is_constant(), "other cases not allowed here");
if (opr->is_virtual()) {
LIR_OpVisitState::OprMode mode = LIR_OpVisitState::inputMode;
BlockBegin* block = block_of_op_with_id(op_id);
if (block->number_of_sux() == 1 && op_id == block->last_lir_instruction_id()) {
if (block->lir()->instructions_list()->last()->as_OpBranch() != NULL) {
if (block->live_out().at(opr->vreg_number())) {
op_id = block->sux_at(0)->first_lir_instruction_id();
mode = LIR_OpVisitState::outputMode;
}
}
}
opr = color_lir_opr(opr, op_id, mode);
assert(!has_call(op_id) || opr->is_stack() || !is_caller_save(reg_num(opr)), "can not have caller-save register operands at calls");
return append_scope_value_for_operand(opr, scope_values);
} else {
assert(value->as_Constant() != NULL, "all other instructions have only virtual operands");
assert(opr->is_constant(), "operand must be constant");
return append_scope_value_for_constant(opr, scope_values);
}
} else {
scope_values->append(_illegal_value);
return 1;
}
}
IRScopeDebugInfo* LinearScan::compute_debug_info_for_scope(int op_id, IRScope* cur_scope, ValueStack* cur_state, ValueStack* innermost_state) {
IRScopeDebugInfo* caller_debug_info = NULL;
ValueStack* caller_state = cur_state->caller_state();
if (caller_state != NULL) {
caller_debug_info = compute_debug_info_for_scope(op_id, cur_scope->caller(), caller_state, innermost_state);
}
GrowableArray<ScopeValue*>* locals = NULL;
GrowableArray<ScopeValue*>* expressions = NULL;
GrowableArray<MonitorValue*>* monitors = NULL;
int nof_locals = cur_state->locals_size();
if (nof_locals > 0) {
locals = new GrowableArray<ScopeValue*>(nof_locals);
int pos = 0;
while (pos < nof_locals) {
assert(pos < cur_state->locals_size(), "why not?");
Value local = cur_state->local_at(pos);
pos += append_scope_value(op_id, local, locals);
assert(locals->length() == pos, "must match");
}
assert(locals->length() == cur_scope->method()->max_locals(), "wrong number of locals");
assert(locals->length() == cur_state->locals_size(), "wrong number of locals");
} else if (cur_scope->method()->max_locals() > 0) {
assert(cur_state->kind() == ValueStack::EmptyExceptionState, "should be");
nof_locals = cur_scope->method()->max_locals();
locals = new GrowableArray<ScopeValue*>(nof_locals);
for(int i = 0; i < nof_locals; i++) {
locals->append(_illegal_value);
}
}
int nof_stack = cur_state->stack_size();
if (nof_stack > 0) {
expressions = new GrowableArray<ScopeValue*>(nof_stack);
int pos = 0;
while (pos < nof_stack) {
Value expression = cur_state->stack_at_inc(pos);
append_scope_value(op_id, expression, expressions);
assert(expressions->length() == pos, "must match");
}
assert(expressions->length() == cur_state->stack_size(), "wrong number of stack entries");
}
int nof_locks = cur_state->locks_size();
if (nof_locks > 0) {
int lock_offset = cur_state->caller_state() != NULL ? cur_state->caller_state()->total_locks_size() : 0;
monitors = new GrowableArray<MonitorValue*>(nof_locks);
for (int i = 0; i < nof_locks; i++) {
monitors->append(location_for_monitor_index(lock_offset + i));
}
}
return new IRScopeDebugInfo(cur_scope, cur_state->bci(), locals, expressions, monitors, caller_debug_info);
}
void LinearScan::compute_debug_info(CodeEmitInfo* info, int op_id) {
TRACE_LINEAR_SCAN(3, tty->print_cr("creating debug information at op_id %d", op_id));
IRScope* innermost_scope = info->scope();
ValueStack* innermost_state = info->stack();
assert(innermost_scope != NULL && innermost_state != NULL, "why is it missing?");
DEBUG_ONLY(check_stack_depth(info, innermost_state->stack_size()));
if (info->_scope_debug_info == NULL) {
info->_scope_debug_info = compute_debug_info_for_scope(op_id, innermost_scope, innermost_state, innermost_state);
} else {
DEBUG_ONLY(assert_equal(info->_scope_debug_info, compute_debug_info_for_scope(op_id, innermost_scope, innermost_state, innermost_state)));
}
}
void LinearScan::assign_reg_num(LIR_OpList* instructions, IntervalWalker* iw) {
LIR_OpVisitState visitor;
int num_inst = instructions->length();
bool has_dead = false;
for (int j = 0; j < num_inst; j++) {
LIR_Op* op = instructions->at(j);
if (op == NULL) { // this can happen when spill-moves are removed in eliminate_spill_moves
has_dead = true;
continue;
}
int op_id = op->id();
visitor.visit(op);
for_each_visitor_mode(mode) {
int n = visitor.opr_count(mode);
for (int k = 0; k < n; k++) {
LIR_Opr opr = visitor.opr_at(mode, k);
if (opr->is_virtual_register()) {
visitor.set_opr_at(mode, k, color_lir_opr(opr, op_id, mode));
}
}
}
if (visitor.info_count() > 0) {
if (compilation()->has_exception_handlers()) {
XHandlers* xhandlers = visitor.all_xhandler();
int n = xhandlers->length();
for (int k = 0; k < n; k++) {
XHandler* handler = xhandlers->handler_at(k);
if (handler->entry_code() != NULL) {
assign_reg_num(handler->entry_code()->instructions_list(), NULL);
}
}
} else {
assert(visitor.all_xhandler()->length() == 0, "missed exception handler");
}
assert(iw != NULL, "needed for compute_oop_map");
compute_oop_map(iw, visitor, op);
if (!use_fpu_stack_allocation()) {
int n = visitor.info_count();
for (int k = 0; k < n; k++) {
compute_debug_info(visitor.info_at(k), op_id);
}
}
}
#ifdef ASSERT
op->verify();
#endif
if (op->code() == lir_move) {
assert(op->as_Op1() != NULL, "move must be LIR_Op1");
LIR_Op1* move = (LIR_Op1*)op;
LIR_Opr src = move->in_opr();
LIR_Opr dst = move->result_opr();
if (dst == src ||
!dst->is_pointer() && !src->is_pointer() &&
src->is_same_register(dst)) {
instructions->at_put(j, NULL);
has_dead = true;
}
}
}
if (has_dead) {
int insert_point = 0;
for (int j = 0; j < num_inst; j++) {
LIR_Op* op = instructions->at(j);
if (op != NULL) {
if (insert_point != j) {
instructions->at_put(insert_point, op);
}
insert_point++;
}
}
instructions->truncate(insert_point);
}
}
void LinearScan::assign_reg_num() {
TIME_LINEAR_SCAN(timer_assign_reg_num);
init_compute_debug_info();
IntervalWalker* iw = init_compute_oop_maps();
int num_blocks = block_count();
for (int i = 0; i < num_blocks; i++) {
BlockBegin* block = block_at(i);
assign_reg_num(block->lir()->instructions_list(), iw);
}
}
void LinearScan::do_linear_scan() {
NOT_PRODUCT(_total_timer.begin_method());
number_instructions();
NOT_PRODUCT(print_lir(1, "Before Register Allocation"));
compute_local_live_sets();
compute_global_live_sets();
CHECK_BAILOUT();
build_intervals();
CHECK_BAILOUT();
sort_intervals_before_allocation();
NOT_PRODUCT(print_intervals("Before Register Allocation"));
NOT_PRODUCT(LinearScanStatistic::compute(this, _stat_before_alloc));
allocate_registers();
CHECK_BAILOUT();
resolve_data_flow();
if (compilation()->has_exception_handlers()) {
resolve_exception_handlers();
}
propagate_spill_slots();
CHECK_BAILOUT();
NOT_PRODUCT(print_intervals("After Register Allocation"));
NOT_PRODUCT(print_lir(2, "LIR after register allocation:"));
sort_intervals_after_allocation();
DEBUG_ONLY(verify());
eliminate_spill_moves();
assign_reg_num();
CHECK_BAILOUT();
NOT_PRODUCT(print_lir(2, "LIR after assignment of register numbers:"));
NOT_PRODUCT(LinearScanStatistic::compute(this, _stat_after_asign));
{ TIME_LINEAR_SCAN(timer_allocate_fpu_stack);
if (use_fpu_stack_allocation()) {
allocate_fpu_stack(); // Only has effect on Intel
NOT_PRODUCT(print_lir(2, "LIR after FPU stack allocation:"));
}
}
{ TIME_LINEAR_SCAN(timer_optimize_lir);
EdgeMoveOptimizer::optimize(ir()->code());
ControlFlowOptimizer::optimize(ir()->code());
ir()->verify();
}
NOT_PRODUCT(print_lir(1, "Before Code Generation", false));
NOT_PRODUCT(LinearScanStatistic::compute(this, _stat_final));
NOT_PRODUCT(_total_timer.end_method(this));
}
#ifndef PRODUCT
void LinearScan::print_timers(double total) {
_total_timer.print(total);
}
void LinearScan::print_statistics() {
_stat_before_alloc.print("before allocation");
_stat_after_asign.print("after assignment of register");
_stat_final.print("after optimization");
}
void LinearScan::print_bitmap(BitMap& b) {
for (unsigned int i = 0; i < b.size(); i++) {
if (b.at(i)) tty->print("%d ", i);
}
tty->cr();
}
void LinearScan::print_intervals(const char* label) {
if (TraceLinearScanLevel >= 1) {
int i;
tty->cr();
tty->print_cr("%s", label);
for (i = 0; i < interval_count(); i++) {
Interval* interval = interval_at(i);
if (interval != NULL) {
interval->print();
}
}
tty->cr();
tty->print_cr("--- Basic Blocks ---");
for (i = 0; i < block_count(); i++) {
BlockBegin* block = block_at(i);
tty->print("B%d [%d, %d, %d, %d] ", block->block_id(), block->first_lir_instruction_id(), block->last_lir_instruction_id(), block->loop_index(), block->loop_depth());
}
tty->cr();
tty->cr();
}
if (PrintCFGToFile) {
CFGPrinter::print_intervals(&_intervals, label);
}
}
void LinearScan::print_lir(int level, const char* label, bool hir_valid) {
if (TraceLinearScanLevel >= level) {
tty->cr();
tty->print_cr("%s", label);
print_LIR(ir()->linear_scan_order());
tty->cr();
}
if (level == 1 && PrintCFGToFile) {
CFGPrinter::print_cfg(ir()->linear_scan_order(), label, hir_valid, true);
}
}
#endif //PRODUCT
#ifdef ASSERT
void LinearScan::verify() {
TRACE_LINEAR_SCAN(2, tty->print_cr("********* verifying intervals ******************************************"));
verify_intervals();
TRACE_LINEAR_SCAN(2, tty->print_cr("********* verifying that no oops are in fixed intervals ****************"));
verify_no_oops_in_fixed_intervals();
TRACE_LINEAR_SCAN(2, tty->print_cr("********* verifying that unpinned constants are not alive across block boundaries"));
verify_constants();
TRACE_LINEAR_SCAN(2, tty->print_cr("********* verifying register allocation ********************************"));
verify_registers();
TRACE_LINEAR_SCAN(2, tty->print_cr("********* no errors found **********************************************"));
}
void LinearScan::verify_intervals() {
int len = interval_count();
bool has_error = false;
for (int i = 0; i < len; i++) {
Interval* i1 = interval_at(i);
if (i1 == NULL) continue;
i1->check_split_children();
if (i1->reg_num() != i) {
tty->print_cr("Interval %d is on position %d in list", i1->reg_num(), i); i1->print(); tty->cr();
has_error = true;
}
if (i1->reg_num() >= LIR_OprDesc::vreg_base && i1->type() == T_ILLEGAL) {
tty->print_cr("Interval %d has no type assigned", i1->reg_num()); i1->print(); tty->cr();
has_error = true;
}
if (i1->assigned_reg() == any_reg) {
tty->print_cr("Interval %d has no register assigned", i1->reg_num()); i1->print(); tty->cr();
has_error = true;
}
if (i1->assigned_reg() == i1->assigned_regHi()) {
tty->print_cr("Interval %d: low and high register equal", i1->reg_num()); i1->print(); tty->cr();
has_error = true;
}
if (!is_processed_reg_num(i1->assigned_reg())) {
tty->print_cr("Can not have an Interval for an ignored register"); i1->print(); tty->cr();
has_error = true;
}
if (i1->first() == Range::end()) {
tty->print_cr("Interval %d has no Range", i1->reg_num()); i1->print(); tty->cr();
has_error = true;
}
for (Range* r = i1->first(); r != Range::end(); r = r->next()) {
if (r->from() >= r->to()) {
tty->print_cr("Interval %d has zero length range", i1->reg_num()); i1->print(); tty->cr();
has_error = true;
}
}
for (int j = i + 1; j < len; j++) {
Interval* i2 = interval_at(j);
if (i2 == NULL) continue;
if (i1->from() == 1 && i1->to() == 2) continue;
if (i2->from() == 1 && i2->to() == 2) continue;
int r1 = i1->assigned_reg();
int r1Hi = i1->assigned_regHi();
int r2 = i2->assigned_reg();
int r2Hi = i2->assigned_regHi();
if (i1->intersects(i2) && (r1 == r2 || r1 == r2Hi || (r1Hi != any_reg && (r1Hi == r2 || r1Hi == r2Hi)))) {
tty->print_cr("Intervals %d and %d overlap and have the same register assigned", i1->reg_num(), i2->reg_num());
i1->print(); tty->cr();
i2->print(); tty->cr();
has_error = true;
}
}
}
assert(has_error == false, "register allocation invalid");
}
void LinearScan::verify_no_oops_in_fixed_intervals() {
Interval* fixed_intervals;
Interval* other_intervals;
create_unhandled_lists(&fixed_intervals, &other_intervals, is_precolored_cpu_interval, NULL);
other_intervals = new Interval(any_reg);
other_intervals->add_range(max_jint - 2, max_jint - 1);
IntervalWalker* iw = new IntervalWalker(this, fixed_intervals, other_intervals);
LIR_OpVisitState visitor;
for (int i = 0; i < block_count(); i++) {
BlockBegin* block = block_at(i);
LIR_OpList* instructions = block->lir()->instructions_list();
for (int j = 0; j < instructions->length(); j++) {
LIR_Op* op = instructions->at(j);
int op_id = op->id();
visitor.visit(op);
if (visitor.info_count() > 0) {
iw->walk_before(op->id());
bool check_live = true;
if (op->code() == lir_move) {
LIR_Op1* move = (LIR_Op1*)op;
check_live = (move->patch_code() == lir_patch_none);
}
LIR_OpBranch* branch = op->as_OpBranch();
if (branch != NULL && branch->stub() != NULL && branch->stub()->is_exception_throw_stub()) {
check_live = false;
}
if (check_live) {
for (Interval* interval = iw->active_first(fixedKind);
interval != Interval::end();
interval = interval->next()) {
if (interval->current_to() > op->id() + 1) {
bool ok = false;
for_each_visitor_mode(mode) {
int n = visitor.opr_count(mode);
for (int k = 0; k < n; k++) {
LIR_Opr opr = visitor.opr_at(mode, k);
if (opr->is_fixed_cpu()) {
if (interval_at(reg_num(opr)) == interval) {
ok = true;
break;
}
int hi = reg_numHi(opr);
if (hi != -1 && interval_at(hi) == interval) {
ok = true;
break;
}
}
}
}
assert(ok, "fixed intervals should never be live across an oopmap point");
}
}
}
}
if (!visitor.has_call()) {
for_each_visitor_mode(mode) {
int n = visitor.opr_count(mode);
for (int k = 0; k < n; k++) {
LIR_Opr opr = visitor.opr_at(mode, k);
if (opr->is_fixed_cpu() && opr->is_oop()) {
TRACE_LINEAR_SCAN(4, op->print_on(tty); tty->print("checking operand "); opr->print(); tty->cr());
Interval* interval = interval_at(reg_num(opr));
assert(interval != NULL, "no interval");
if (mode == LIR_OpVisitState::inputMode) {
if (interval->to() >= op_id + 1) {
assert(interval->to() < op_id + 2 ||
interval->has_hole_between(op_id, op_id + 2),
"oop input operand live after instruction");
}
} else if (mode == LIR_OpVisitState::outputMode) {
if (interval->from() <= op_id - 1) {
assert(interval->has_hole_between(op_id - 1, op_id),
"oop input operand live after instruction");
}
}
}
}
}
}
}
}
}
void LinearScan::verify_constants() {
int num_regs = num_virtual_regs();
int size = live_set_size();
int num_blocks = block_count();
for (int i = 0; i < num_blocks; i++) {
BlockBegin* block = block_at(i);
BitMap live_at_edge = block->live_in();
for (int r = (int)live_at_edge.get_next_one_offset(0, size); r < size; r = (int)live_at_edge.get_next_one_offset(r + 1, size)) {
TRACE_LINEAR_SCAN(4, tty->print("checking interval %d of block B%d", r, block->block_id()));
Value value = gen()->instruction_for_vreg(r);
assert(value != NULL, "all intervals live across block boundaries must have Value");
assert(value->operand()->is_register() && value->operand()->is_virtual(), "value must have virtual operand");
assert(value->operand()->vreg_number() == r, "register number must match");
}
}
}
class RegisterVerifier: public StackObj {
private:
LinearScan* _allocator;
BlockList _work_list; // all blocks that must be processed
IntervalsList _saved_states; // saved information of previous check
Compilation* compilation() const { return _allocator->compilation(); }
Interval* interval_at(int reg_num) const { return _allocator->interval_at(reg_num); }
int reg_num(LIR_Opr opr) const { return _allocator->reg_num(opr); }
int state_size() { return LinearScan::nof_regs; }
IntervalList* state_for_block(BlockBegin* block) { return _saved_states.at(block->block_id()); }
void set_state_for_block(BlockBegin* block, IntervalList* saved_state) { _saved_states.at_put(block->block_id(), saved_state); }
void add_to_work_list(BlockBegin* block) { if (!_work_list.contains(block)) _work_list.append(block); }
IntervalList* copy(IntervalList* input_state);
void state_put(IntervalList* input_state, int reg, Interval* interval);
bool check_state(IntervalList* input_state, int reg, Interval* interval);
void process_block(BlockBegin* block);
void process_xhandler(XHandler* xhandler, IntervalList* input_state);
void process_successor(BlockBegin* block, IntervalList* input_state);
void process_operations(LIR_List* ops, IntervalList* input_state);
public:
RegisterVerifier(LinearScan* allocator)
: _allocator(allocator)
, _work_list(16)
, _saved_states(BlockBegin::number_of_blocks(), NULL)
{ }
void verify(BlockBegin* start);
};
void LinearScan::verify_registers() {
RegisterVerifier verifier(this);
verifier.verify(block_at(0));
}
void RegisterVerifier::verify(BlockBegin* start) {
IntervalList* input_state = new IntervalList(state_size(), NULL);
CallingConvention* args = compilation()->frame_map()->incoming_arguments();
for (int n = 0; n < args->length(); n++) {
LIR_Opr opr = args->at(n);
if (opr->is_register()) {
Interval* interval = interval_at(reg_num(opr));
if (interval->assigned_reg() < state_size()) {
input_state->at_put(interval->assigned_reg(), interval);
}
if (interval->assigned_regHi() != LinearScan::any_reg && interval->assigned_regHi() < state_size()) {
input_state->at_put(interval->assigned_regHi(), interval);
}
}
}
set_state_for_block(start, input_state);
add_to_work_list(start);
do {
BlockBegin* block = _work_list.at(0);
_work_list.remove_at(0);
process_block(block);
} while (!_work_list.is_empty());
}
void RegisterVerifier::process_block(BlockBegin* block) {
TRACE_LINEAR_SCAN(2, tty->cr(); tty->print_cr("process_block B%d", block->block_id()));
IntervalList* input_state = copy(state_for_block(block));
if (TraceLinearScanLevel >= 4) {
tty->print_cr("Input-State of intervals:");
tty->print(" ");
for (int i = 0; i < state_size(); i++) {
if (input_state->at(i) != NULL) {
tty->print(" %4d", input_state->at(i)->reg_num());
} else {
tty->print(" __");
}
}
tty->cr();
tty->cr();
}
process_operations(block->lir(), input_state);
for (int i = 0; i < block->number_of_sux(); i++) {
process_successor(block->sux_at(i), input_state);
}
}
void RegisterVerifier::process_xhandler(XHandler* xhandler, IntervalList* input_state) {
TRACE_LINEAR_SCAN(2, tty->print_cr("process_xhandler B%d", xhandler->entry_block()->block_id()));
input_state = copy(input_state);
if (xhandler->entry_code() != NULL) {
process_operations(xhandler->entry_code(), input_state);
}
process_successor(xhandler->entry_block(), input_state);
}
void RegisterVerifier::process_successor(BlockBegin* block, IntervalList* input_state) {
IntervalList* saved_state = state_for_block(block);
if (saved_state != NULL) {
bool saved_state_correct = true;
for (int i = 0; i < state_size(); i++) {
if (input_state->at(i) != saved_state->at(i)) {
if (saved_state->at(i) != NULL) {
saved_state_correct = false;
saved_state->at_put(i, NULL);
TRACE_LINEAR_SCAN(4, tty->print_cr("process_successor B%d: invalidating slot %d", block->block_id(), i));
}
}
}
if (saved_state_correct) {
TRACE_LINEAR_SCAN(2, tty->print_cr("process_successor B%d: previous visit already correct", block->block_id()));
} else {
TRACE_LINEAR_SCAN(2, tty->print_cr("process_successor B%d: must re-visit because input state changed", block->block_id()));
add_to_work_list(block);
}
} else {
TRACE_LINEAR_SCAN(2, tty->print_cr("process_successor B%d: initial visit", block->block_id()));
set_state_for_block(block, copy(input_state));
add_to_work_list(block);
}
}
IntervalList* RegisterVerifier::copy(IntervalList* input_state) {
IntervalList* copy_state = new IntervalList(input_state->length());
copy_state->push_all(input_state);
return copy_state;
}
void RegisterVerifier::state_put(IntervalList* input_state, int reg, Interval* interval) {
if (reg != LinearScan::any_reg && reg < state_size()) {
if (interval != NULL) {
TRACE_LINEAR_SCAN(4, tty->print_cr(" reg[%d] = %d", reg, interval->reg_num()));
} else if (input_state->at(reg) != NULL) {
TRACE_LINEAR_SCAN(4, tty->print_cr(" reg[%d] = NULL", reg));
}
input_state->at_put(reg, interval);
}
}
bool RegisterVerifier::check_state(IntervalList* input_state, int reg, Interval* interval) {
if (reg != LinearScan::any_reg && reg < state_size()) {
if (input_state->at(reg) != interval) {
tty->print_cr("!! Error in register allocation: register %d does not contain interval %d", reg, interval->reg_num());
return true;
}
}
return false;
}
void RegisterVerifier::process_operations(LIR_List* ops, IntervalList* input_state) {
LIR_OpVisitState visitor;
bool has_error = false;
for (int i = 0; i < ops->length(); i++) {
LIR_Op* op = ops->at(i);
visitor.visit(op);
TRACE_LINEAR_SCAN(4, op->print_on(tty));
int j;
int n = visitor.opr_count(LIR_OpVisitState::inputMode);
for (j = 0; j < n; j++) {
LIR_Opr opr = visitor.opr_at(LIR_OpVisitState::inputMode, j);
if (opr->is_register() && LinearScan::is_processed_reg_num(reg_num(opr))) {
Interval* interval = interval_at(reg_num(opr));
if (op->id() != -1) {
interval = interval->split_child_at_op_id(op->id(), LIR_OpVisitState::inputMode);
}
has_error |= check_state(input_state, interval->assigned_reg(), interval->split_parent());
has_error |= check_state(input_state, interval->assigned_regHi(), interval->split_parent());
if (opr->is_last_use()) {
state_put(input_state, interval->assigned_reg(), NULL);
state_put(input_state, interval->assigned_regHi(), NULL);
}
}
}
if (visitor.has_call()) {
for (j = 0; j < FrameMap::nof_caller_save_cpu_regs(); j++) {
state_put(input_state, reg_num(FrameMap::caller_save_cpu_reg_at(j)), NULL);
}
for (j = 0; j < FrameMap::nof_caller_save_fpu_regs; j++) {
state_put(input_state, reg_num(FrameMap::caller_save_fpu_reg_at(j)), NULL);
}
#ifdef X86
for (j = 0; j < FrameMap::nof_caller_save_xmm_regs; j++) {
state_put(input_state, reg_num(FrameMap::caller_save_xmm_reg_at(j)), NULL);
}
#endif
}
XHandlers* xhandlers = visitor.all_xhandler();
n = xhandlers->length();
for (int k = 0; k < n; k++) {
process_xhandler(xhandlers->handler_at(k), input_state);
}
n = visitor.opr_count(LIR_OpVisitState::tempMode);
for (j = 0; j < n; j++) {
LIR_Opr opr = visitor.opr_at(LIR_OpVisitState::tempMode, j);
if (opr->is_register() && LinearScan::is_processed_reg_num(reg_num(opr))) {
Interval* interval = interval_at(reg_num(opr));
if (op->id() != -1) {
interval = interval->split_child_at_op_id(op->id(), LIR_OpVisitState::tempMode);
}
state_put(input_state, interval->assigned_reg(), interval->split_parent());
state_put(input_state, interval->assigned_regHi(), interval->split_parent());
}
}
n = visitor.opr_count(LIR_OpVisitState::outputMode);
for (j = 0; j < n; j++) {
LIR_Opr opr = visitor.opr_at(LIR_OpVisitState::outputMode, j);
if (opr->is_register() && LinearScan::is_processed_reg_num(reg_num(opr))) {
Interval* interval = interval_at(reg_num(opr));
if (op->id() != -1) {
interval = interval->split_child_at_op_id(op->id(), LIR_OpVisitState::outputMode);
}
state_put(input_state, interval->assigned_reg(), interval->split_parent());
state_put(input_state, interval->assigned_regHi(), interval->split_parent());
}
}
}
assert(has_error == false, "Error in register allocation");
}
#endif // ASSERT
MoveResolver::MoveResolver(LinearScan* allocator) :
_allocator(allocator),
_multiple_reads_allowed(false),
_mapping_from(8),
_mapping_from_opr(8),
_mapping_to(8),
_insert_list(NULL),
_insert_idx(-1),
_insertion_buffer()
{
for (int i = 0; i < LinearScan::nof_regs; i++) {
_register_blocked[i] = 0;
}
DEBUG_ONLY(check_empty());
}
#ifdef ASSERT
void MoveResolver::check_empty() {
assert(_mapping_from.length() == 0 && _mapping_from_opr.length() == 0 && _mapping_to.length() == 0, "list must be empty before and after processing");
for (int i = 0; i < LinearScan::nof_regs; i++) {
assert(register_blocked(i) == 0, "register map must be empty before and after processing");
}
assert(_multiple_reads_allowed == false, "must have default value");
}
void MoveResolver::verify_before_resolve() {
assert(_mapping_from.length() == _mapping_from_opr.length(), "length must be equal");
assert(_mapping_from.length() == _mapping_to.length(), "length must be equal");
assert(_insert_list != NULL && _insert_idx != -1, "insert position not set");
int i, j;
if (!_multiple_reads_allowed) {
for (i = 0; i < _mapping_from.length(); i++) {
for (j = i + 1; j < _mapping_from.length(); j++) {
assert(_mapping_from.at(i) == NULL || _mapping_from.at(i) != _mapping_from.at(j), "cannot read from same interval twice");
}
}
}
for (i = 0; i < _mapping_to.length(); i++) {
for (j = i + 1; j < _mapping_to.length(); j++) {
assert(_mapping_to.at(i) != _mapping_to.at(j), "cannot write to same interval twice");
}
}
BitMap used_regs(LinearScan::nof_regs + allocator()->frame_map()->argcount() + allocator()->max_spills());
used_regs.clear();
if (!_multiple_reads_allowed) {
for (i = 0; i < _mapping_from.length(); i++) {
Interval* it = _mapping_from.at(i);
if (it != NULL) {
assert(!used_regs.at(it->assigned_reg()), "cannot read from same register twice");
used_regs.set_bit(it->assigned_reg());
if (it->assigned_regHi() != LinearScan::any_reg) {
assert(!used_regs.at(it->assigned_regHi()), "cannot read from same register twice");
used_regs.set_bit(it->assigned_regHi());
}
}
}
}
used_regs.clear();
for (i = 0; i < _mapping_to.length(); i++) {
Interval* it = _mapping_to.at(i);
assert(!used_regs.at(it->assigned_reg()), "cannot write to same register twice");
used_regs.set_bit(it->assigned_reg());
if (it->assigned_regHi() != LinearScan::any_reg) {
assert(!used_regs.at(it->assigned_regHi()), "cannot write to same register twice");
used_regs.set_bit(it->assigned_regHi());
}
}
used_regs.clear();
for (i = 0; i < _mapping_from.length(); i++) {
Interval* it = _mapping_from.at(i);
if (it != NULL && it->assigned_reg() >= LinearScan::nof_regs) {
used_regs.set_bit(it->assigned_reg());
}
}
for (i = 0; i < _mapping_to.length(); i++) {
Interval* it = _mapping_to.at(i);
assert(!used_regs.at(it->assigned_reg()) || it->assigned_reg() == _mapping_from.at(i)->assigned_reg(), "stack slots used in _mapping_from must be disjoint to _mapping_to");
}
}
#endif // ASSERT
void MoveResolver::block_registers(Interval* it) {
int reg = it->assigned_reg();
if (reg < LinearScan::nof_regs) {
assert(_multiple_reads_allowed || register_blocked(reg) == 0, "register already marked as used");
set_register_blocked(reg, 1);
}
reg = it->assigned_regHi();
if (reg != LinearScan::any_reg && reg < LinearScan::nof_regs) {
assert(_multiple_reads_allowed || register_blocked(reg) == 0, "register already marked as used");
set_register_blocked(reg, 1);
}
}
void MoveResolver::unblock_registers(Interval* it) {
int reg = it->assigned_reg();
if (reg < LinearScan::nof_regs) {
assert(register_blocked(reg) > 0, "register already marked as unused");
set_register_blocked(reg, -1);
}
reg = it->assigned_regHi();
if (reg != LinearScan::any_reg && reg < LinearScan::nof_regs) {
assert(register_blocked(reg) > 0, "register already marked as unused");
set_register_blocked(reg, -1);
}
}
bool MoveResolver::save_to_process_move(Interval* from, Interval* to) {
int from_reg = -1;
int from_regHi = -1;
if (from != NULL) {
from_reg = from->assigned_reg();
from_regHi = from->assigned_regHi();
}
int reg = to->assigned_reg();
if (reg < LinearScan::nof_regs) {
if (register_blocked(reg) > 1 || (register_blocked(reg) == 1 && reg != from_reg && reg != from_regHi)) {
return false;
}
}
reg = to->assigned_regHi();
if (reg != LinearScan::any_reg && reg < LinearScan::nof_regs) {
if (register_blocked(reg) > 1 || (register_blocked(reg) == 1 && reg != from_reg && reg != from_regHi)) {
return false;
}
}
return true;
}
void MoveResolver::create_insertion_buffer(LIR_List* list) {
assert(!_insertion_buffer.initialized(), "overwriting existing buffer");
_insertion_buffer.init(list);
}
void MoveResolver::append_insertion_buffer() {
if (_insertion_buffer.initialized()) {
_insertion_buffer.lir_list()->append(&_insertion_buffer);
}
assert(!_insertion_buffer.initialized(), "must be uninitialized now");
_insert_list = NULL;
_insert_idx = -1;
}
void MoveResolver::insert_move(Interval* from_interval, Interval* to_interval) {
assert(from_interval->reg_num() != to_interval->reg_num(), "from and to interval equal");
assert(from_interval->type() == to_interval->type(), "move between different types");
assert(_insert_list != NULL && _insert_idx != -1, "must setup insert position first");
assert(_insertion_buffer.lir_list() == _insert_list, "wrong insertion buffer");
LIR_Opr from_opr = LIR_OprFact::virtual_register(from_interval->reg_num(), from_interval->type());
LIR_Opr to_opr = LIR_OprFact::virtual_register(to_interval->reg_num(), to_interval->type());
if (!_multiple_reads_allowed) {
from_opr = from_opr->make_last_use();
}
_insertion_buffer.move(_insert_idx, from_opr, to_opr);
TRACE_LINEAR_SCAN(4, tty->print_cr("MoveResolver: inserted move from register %d (%d, %d) to %d (%d, %d)", from_interval->reg_num(), from_interval->assigned_reg(), from_interval->assigned_regHi(), to_interval->reg_num(), to_interval->assigned_reg(), to_interval->assigned_regHi()));
}
void MoveResolver::insert_move(LIR_Opr from_opr, Interval* to_interval) {
assert(from_opr->type() == to_interval->type(), "move between different types");
assert(_insert_list != NULL && _insert_idx != -1, "must setup insert position first");
assert(_insertion_buffer.lir_list() == _insert_list, "wrong insertion buffer");
LIR_Opr to_opr = LIR_OprFact::virtual_register(to_interval->reg_num(), to_interval->type());
_insertion_buffer.move(_insert_idx, from_opr, to_opr);
TRACE_LINEAR_SCAN(4, tty->print("MoveResolver: inserted move from constant "); from_opr->print(); tty->print_cr(" to %d (%d, %d)", to_interval->reg_num(), to_interval->assigned_reg(), to_interval->assigned_regHi()));
}
void MoveResolver::resolve_mappings() {
TRACE_LINEAR_SCAN(4, tty->print_cr("MoveResolver: resolving mappings for Block B%d, index %d", _insert_list->block() != NULL ? _insert_list->block()->block_id() : -1, _insert_idx));
DEBUG_ONLY(verify_before_resolve());
int i;
for (i = _mapping_from.length() - 1; i >= 0; i--) {
Interval* from_interval = _mapping_from.at(i);
if (from_interval != NULL) {
block_registers(from_interval);
}
}
int spill_candidate = -1;
while (_mapping_from.length() > 0) {
bool processed_interval = false;
for (i = _mapping_from.length() - 1; i >= 0; i--) {
Interval* from_interval = _mapping_from.at(i);
Interval* to_interval = _mapping_to.at(i);
if (save_to_process_move(from_interval, to_interval)) {
if (from_interval != NULL) {
insert_move(from_interval, to_interval);
unblock_registers(from_interval);
} else {
insert_move(_mapping_from_opr.at(i), to_interval);
}
_mapping_from.remove_at(i);
_mapping_from_opr.remove_at(i);
_mapping_to.remove_at(i);
processed_interval = true;
} else if (from_interval != NULL && from_interval->assigned_reg() < LinearScan::nof_regs) {
spill_candidate = i;
}
}
if (!processed_interval) {
assert(spill_candidate != -1, "no interval in register for spilling found");
Interval* from_interval = _mapping_from.at(spill_candidate);
Interval* spill_interval = new Interval(-1);
spill_interval->set_type(from_interval->type());
spill_interval->add_range(1, 2);
int spill_slot = from_interval->canonical_spill_slot();
if (spill_slot < 0) {
spill_slot = allocator()->allocate_spill_slot(type2spill_size[spill_interval->type()] == 2);
from_interval->set_canonical_spill_slot(spill_slot);
}
spill_interval->assign_reg(spill_slot);
allocator()->append_interval(spill_interval);
TRACE_LINEAR_SCAN(4, tty->print_cr("created new Interval %d for spilling", spill_interval->reg_num()));
insert_move(from_interval, spill_interval);
_mapping_from.at_put(spill_candidate, spill_interval);
unblock_registers(from_interval);
}
}
_multiple_reads_allowed = false;
DEBUG_ONLY(check_empty());
}
void MoveResolver::set_insert_position(LIR_List* insert_list, int insert_idx) {
TRACE_LINEAR_SCAN(4, tty->print_cr("MoveResolver: setting insert position to Block B%d, index %d", insert_list->block() != NULL ? insert_list->block()->block_id() : -1, insert_idx));
assert(_insert_list == NULL && _insert_idx == -1, "use move_insert_position instead of set_insert_position when data already set");
create_insertion_buffer(insert_list);
_insert_list = insert_list;
_insert_idx = insert_idx;
}
void MoveResolver::move_insert_position(LIR_List* insert_list, int insert_idx) {
TRACE_LINEAR_SCAN(4, tty->print_cr("MoveResolver: moving insert position to Block B%d, index %d", insert_list->block() != NULL ? insert_list->block()->block_id() : -1, insert_idx));
if (_insert_list != NULL && (insert_list != _insert_list || insert_idx != _insert_idx)) {
resolve_mappings();
}
if (insert_list != _insert_list) {
append_insertion_buffer();
create_insertion_buffer(insert_list);
}
_insert_list = insert_list;
_insert_idx = insert_idx;
}
void MoveResolver::add_mapping(Interval* from_interval, Interval* to_interval) {
TRACE_LINEAR_SCAN(4, tty->print_cr("MoveResolver: adding mapping from %d (%d, %d) to %d (%d, %d)", from_interval->reg_num(), from_interval->assigned_reg(), from_interval->assigned_regHi(), to_interval->reg_num(), to_interval->assigned_reg(), to_interval->assigned_regHi()));
_mapping_from.append(from_interval);
_mapping_from_opr.append(LIR_OprFact::illegalOpr);
_mapping_to.append(to_interval);
}
void MoveResolver::add_mapping(LIR_Opr from_opr, Interval* to_interval) {
TRACE_LINEAR_SCAN(4, tty->print("MoveResolver: adding mapping from "); from_opr->print(); tty->print_cr(" to %d (%d, %d)", to_interval->reg_num(), to_interval->assigned_reg(), to_interval->assigned_regHi()));
assert(from_opr->is_constant(), "only for constants");
_mapping_from.append(NULL);
_mapping_from_opr.append(from_opr);
_mapping_to.append(to_interval);
}
void MoveResolver::resolve_and_append_moves() {
if (has_mappings()) {
resolve_mappings();
}
append_insertion_buffer();
}
Range::Range(int from, int to, Range* next) :
_from(from),
_to(to),
_next(next)
{
}
Range* Range::_end = NULL;
void Range::initialize(Arena* arena) {
_end = new (arena) Range(max_jint, max_jint, NULL);
}
int Range::intersects_at(Range* r2) const {
const Range* r1 = this;
assert(r1 != NULL && r2 != NULL, "null ranges not allowed");
assert(r1 != _end && r2 != _end, "empty ranges not allowed");
do {
if (r1->from() < r2->from()) {
if (r1->to() <= r2->from()) {
r1 = r1->next(); if (r1 == _end) return -1;
} else {
return r2->from();
}
} else if (r2->from() < r1->from()) {
if (r2->to() <= r1->from()) {
r2 = r2->next(); if (r2 == _end) return -1;
} else {
return r1->from();
}
} else { // r1->from() == r2->from()
if (r1->from() == r1->to()) {
r1 = r1->next(); if (r1 == _end) return -1;
} else if (r2->from() == r2->to()) {
r2 = r2->next(); if (r2 == _end) return -1;
} else {
return r1->from();
}
}
} while (true);
}
#ifndef PRODUCT
void Range::print(outputStream* out) const {
out->print("[%d, %d[ ", _from, _to);
}
#endif
Interval* Interval::_end = NULL;
void Interval::initialize(Arena* arena) {
Range::initialize(arena);
_end = new (arena) Interval(-1);
}
Interval::Interval(int reg_num) :
_reg_num(reg_num),
_type(T_ILLEGAL),
_first(Range::end()),
_use_pos_and_kinds(12),
_current(Range::end()),
_next(_end),
_state(invalidState),
_assigned_reg(LinearScan::any_reg),
_assigned_regHi(LinearScan::any_reg),
_cached_to(-1),
_cached_opr(LIR_OprFact::illegalOpr),
_cached_vm_reg(VMRegImpl::Bad()),
_split_children(0),
_canonical_spill_slot(-1),
_insert_move_when_activated(false),
_register_hint(NULL),
_spill_state(noDefinitionFound),
_spill_definition_pos(-1)
{
_split_parent = this;
_current_split_child = this;
}
int Interval::calc_to() {
assert(_first != Range::end(), "interval has no range");
Range* r = _first;
while (r->next() != Range::end()) {
r = r->next();
}
return r->to();
}
#ifdef ASSERT
void Interval::check_split_children() {
if (_split_children.length() > 0) {
assert(is_split_parent(), "only split parents can have children");
for (int i = 0; i < _split_children.length(); i++) {
Interval* i1 = _split_children.at(i);
assert(i1->split_parent() == this, "not a split child of this interval");
assert(i1->type() == type(), "must be equal for all split children");
assert(i1->canonical_spill_slot() == canonical_spill_slot(), "must be equal for all split children");
for (int j = i + 1; j < _split_children.length(); j++) {
Interval* i2 = _split_children.at(j);
assert(i1->reg_num() != i2->reg_num(), "same register number");
if (i1->from() < i2->from()) {
assert(i1->to() <= i2->from() && i1->to() < i2->to(), "intervals overlapping");
} else {
assert(i2->from() < i1->from(), "intervals start at same op_id");
assert(i2->to() <= i1->from() && i2->to() < i1->to(), "intervals overlapping");
}
}
}
}
}
#endif // ASSERT
Interval* Interval::register_hint(bool search_split_child) const {
if (!search_split_child) {
return _register_hint;
}
if (_register_hint != NULL) {
assert(_register_hint->is_split_parent(), "ony split parents are valid hint registers");
if (_register_hint->assigned_reg() >= 0 && _register_hint->assigned_reg() < LinearScan::nof_regs) {
return _register_hint;
} else if (_register_hint->_split_children.length() > 0) {
int len = _register_hint->_split_children.length();
for (int i = 0; i < len; i++) {
Interval* cur = _register_hint->_split_children.at(i);
if (cur->assigned_reg() >= 0 && cur->assigned_reg() < LinearScan::nof_regs) {
return cur;
}
}
}
}
return NULL;
}
Interval* Interval::split_child_at_op_id(int op_id, LIR_OpVisitState::OprMode mode) {
assert(is_split_parent(), "can only be called for split parents");
assert(op_id >= 0, "invalid op_id (method can not be called for spill moves)");
Interval* result;
if (_split_children.length() == 0) {
result = this;
} else {
result = NULL;
int len = _split_children.length();
int to_offset = (mode == LIR_OpVisitState::outputMode ? 0 : 1);
int i;
for (i = 0; i < len; i++) {
Interval* cur = _split_children.at(i);
if (cur->from() <= op_id && op_id < cur->to() + to_offset) {
if (i > 0) {
_split_children.at_put(i, _split_children.at(0));
_split_children.at_put(0, cur);
}
result = cur;
break;
}
}
#ifdef ASSERT
for (i = 0; i < len; i++) {
Interval* tmp = _split_children.at(i);
if (tmp != result && tmp->from() <= op_id && op_id < tmp->to() + to_offset) {
tty->print_cr("two valid result intervals found for op_id %d: %d and %d", op_id, result->reg_num(), tmp->reg_num());
result->print();
tmp->print();
assert(false, "two valid result intervals found");
}
}
#endif
}
assert(result != NULL, "no matching interval found");
assert(result->covers(op_id, mode), "op_id not covered by interval");
return result;
}
Interval* Interval::split_child_before_op_id(int op_id) {
assert(op_id >= 0, "invalid op_id");
Interval* parent = split_parent();
Interval* result = NULL;
int len = parent->_split_children.length();
assert(len > 0, "no split children available");
for (int i = len - 1; i >= 0; i--) {
Interval* cur = parent->_split_children.at(i);
if (cur->to() <= op_id && (result == NULL || result->to() < cur->to())) {
result = cur;
}
}
assert(result != NULL, "no split child found");
return result;
}
bool Interval::split_child_covers(int op_id, LIR_OpVisitState::OprMode mode) {
assert(is_split_parent(), "can only be called for split parents");
assert(op_id >= 0, "invalid op_id (method can not be called for spill moves)");
if (_split_children.length() == 0) {
return covers(op_id, mode);
} else {
int len = _split_children.length();
for (int i = 0; i < len; i++) {
Interval* cur = _split_children.at(i);
if (cur->covers(op_id, mode)) {
return true;
}
}
return false;
}
}
int Interval::first_usage(IntervalUseKind min_use_kind) const {
assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
for (int i = _use_pos_and_kinds.length() - 2; i >= 0; i -= 2) {
if (_use_pos_and_kinds.at(i + 1) >= min_use_kind) {
return _use_pos_and_kinds.at(i);
}
}
return max_jint;
}
int Interval::next_usage(IntervalUseKind min_use_kind, int from) const {
assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
for (int i = _use_pos_and_kinds.length() - 2; i >= 0; i -= 2) {
if (_use_pos_and_kinds.at(i) >= from && _use_pos_and_kinds.at(i + 1) >= min_use_kind) {
return _use_pos_and_kinds.at(i);
}
}
return max_jint;
}
int Interval::next_usage_exact(IntervalUseKind exact_use_kind, int from) const {
assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
for (int i = _use_pos_and_kinds.length() - 2; i >= 0; i -= 2) {
if (_use_pos_and_kinds.at(i) >= from && _use_pos_and_kinds.at(i + 1) == exact_use_kind) {
return _use_pos_and_kinds.at(i);
}
}
return max_jint;
}
int Interval::previous_usage(IntervalUseKind min_use_kind, int from) const {
assert(LinearScan::is_virtual_interval(this), "cannot access use positions for fixed intervals");
int prev = 0;
for (int i = _use_pos_and_kinds.length() - 2; i >= 0; i -= 2) {
if (_use_pos_and_kinds.at(i) > from) {
return prev;
}
if (_use_pos_and_kinds.at(i + 1) >= min_use_kind) {
prev = _use_pos_and_kinds.at(i);
}
}
return prev;
}
void Interval::add_use_pos(int pos, IntervalUseKind use_kind) {
assert(covers(pos, LIR_OpVisitState::inputMode), "use position not covered by live range");
if (use_kind != noUse && reg_num() >= LIR_OprDesc::vreg_base) {
#ifdef ASSERT
assert(_use_pos_and_kinds.length() % 2 == 0, "must be");
for (int i = 0; i < _use_pos_and_kinds.length(); i += 2) {
assert(pos <= _use_pos_and_kinds.at(i), "already added a use-position with lower position");
assert(_use_pos_and_kinds.at(i + 1) >= firstValidKind && _use_pos_and_kinds.at(i + 1) <= lastValidKind, "invalid use kind");
if (i > 0) {
assert(_use_pos_and_kinds.at(i) < _use_pos_and_kinds.at(i - 2), "not sorted descending");
}
}
#endif
int len = _use_pos_and_kinds.length();
if (len == 0 || _use_pos_and_kinds.at(len - 2) > pos) {
_use_pos_and_kinds.append(pos);
_use_pos_and_kinds.append(use_kind);
} else if (_use_pos_and_kinds.at(len - 1) < use_kind) {
assert(_use_pos_and_kinds.at(len - 2) == pos, "list not sorted correctly");
_use_pos_and_kinds.at_put(len - 1, use_kind);
}
}
}
void Interval::add_range(int from, int to) {
assert(from < to, "invalid range");
assert(first() == Range::end() || to < first()->next()->from(), "not inserting at begin of interval");
assert(from <= first()->to(), "not inserting at begin of interval");
if (first()->from() <= to) {
first()->set_from(MIN2(from, first()->from()));
first()->set_to (MAX2(to, first()->to()));
} else {
_first = new Range(from, to, first());
}
}
Interval* Interval::new_split_child() {
Interval* result = new Interval(-1);
result->set_type(type());
Interval* parent = split_parent();
result->_split_parent = parent;
result->set_register_hint(parent);
if (parent->_split_children.length() == 0) {
assert(is_split_parent(), "list must be initialized at first split");
parent->_split_children = IntervalList(4);
parent->_split_children.append(this);
}
parent->_split_children.append(result);
return result;
}
Interval* Interval::split(int split_pos) {
assert(LinearScan::is_virtual_interval(this), "cannot split fixed intervals");
Interval* result = new_split_child();
Range* prev = NULL;
Range* cur = _first;
while (cur != Range::end() && cur->to() <= split_pos) {
prev = cur;
cur = cur->next();
}
assert(cur != Range::end(), "split interval after end of last range");
if (cur->from() < split_pos) {
result->_first = new Range(split_pos, cur->to(), cur->next());
cur->set_to(split_pos);
cur->set_next(Range::end());
} else {
assert(prev != NULL, "split before start of first range");
result->_first = cur;
prev->set_next(Range::end());
}
result->_current = result->_first;
_cached_to = -1; // clear cached value
int total_len = _use_pos_and_kinds.length();
int start_idx = total_len - 2;
while (start_idx >= 0 && _use_pos_and_kinds.at(start_idx) < split_pos) {
start_idx -= 2;
}
intStack new_use_pos_and_kinds(total_len - start_idx);
int i;
for (i = start_idx + 2; i < total_len; i++) {
new_use_pos_and_kinds.append(_use_pos_and_kinds.at(i));
}
_use_pos_and_kinds.truncate(start_idx + 2);
result->_use_pos_and_kinds = _use_pos_and_kinds;
_use_pos_and_kinds = new_use_pos_and_kinds;
#ifdef ASSERT
assert(_use_pos_and_kinds.length() % 2 == 0, "must have use kind for each use pos");
assert(result->_use_pos_and_kinds.length() % 2 == 0, "must have use kind for each use pos");
assert(_use_pos_and_kinds.length() + result->_use_pos_and_kinds.length() == total_len, "missed some entries");
for (i = 0; i < _use_pos_and_kinds.length(); i += 2) {
assert(_use_pos_and_kinds.at(i) < split_pos, "must be");
assert(_use_pos_and_kinds.at(i + 1) >= firstValidKind && _use_pos_and_kinds.at(i + 1) <= lastValidKind, "invalid use kind");
}
for (i = 0; i < result->_use_pos_and_kinds.length(); i += 2) {
assert(result->_use_pos_and_kinds.at(i) >= split_pos, "must be");
assert(result->_use_pos_and_kinds.at(i + 1) >= firstValidKind && result->_use_pos_and_kinds.at(i + 1) <= lastValidKind, "invalid use kind");
}
#endif
return result;
}
Interval* Interval::split_from_start(int split_pos) {
assert(LinearScan::is_virtual_interval(this), "cannot split fixed intervals");
assert(split_pos > from() && split_pos < to(), "can only split inside interval");
assert(split_pos > _first->from() && split_pos <= _first->to(), "can only split inside first range");
assert(first_usage(noUse) > split_pos, "can not split when use positions are present");
Interval* result = new_split_child();
result->add_range(_first->from(), split_pos);
if (split_pos == _first->to()) {
assert(_first->next() != Range::end(), "must not be at end");
_first = _first->next();
} else {
_first->set_from(split_pos);
}
return result;
}
bool Interval::covers(int op_id, LIR_OpVisitState::OprMode mode) const {
Range* cur = _first;
while (cur != Range::end() && cur->to() < op_id) {
cur = cur->next();
}
if (cur != Range::end()) {
assert(cur->to() != cur->next()->from(), "ranges not separated");
if (mode == LIR_OpVisitState::outputMode) {
return cur->from() <= op_id && op_id < cur->to();
} else {
return cur->from() <= op_id && op_id <= cur->to();
}
}
return false;
}
bool Interval::has_hole_between(int hole_from, int hole_to) {
assert(hole_from < hole_to, "check");
assert(from() <= hole_from && hole_to <= to(), "index out of interval");
Range* cur = _first;
while (cur != Range::end()) {
assert(cur->to() < cur->next()->from(), "no space between ranges");
if (hole_from < cur->from()) {
return true;
} else if (hole_to <= cur->to()) {
return false;
} else if (hole_from <= cur->to()) {
return true;
}
cur = cur->next();
}
return false;
}
#ifndef PRODUCT
void Interval::print(outputStream* out) const {
const char* SpillState2Name[] = { "no definition", "no spill store", "one spill store", "store at definition", "start in memory", "no optimization" };
const char* UseKind2Name[] = { "N", "L", "S", "M" };
const char* type_name;
LIR_Opr opr = LIR_OprFact::illegal();
if (reg_num() < LIR_OprDesc::vreg_base) {
type_name = "fixed";
if (assigned_reg() >= pd_first_cpu_reg && assigned_reg() <= pd_last_cpu_reg) {
opr = LIR_OprFact::single_cpu(assigned_reg());
} else if (assigned_reg() >= pd_first_fpu_reg && assigned_reg() <= pd_last_fpu_reg) {
opr = LIR_OprFact::single_fpu(assigned_reg() - pd_first_fpu_reg);
#ifdef X86
} else if (assigned_reg() >= pd_first_xmm_reg && assigned_reg() <= pd_last_xmm_reg) {
opr = LIR_OprFact::single_xmm(assigned_reg() - pd_first_xmm_reg);
#endif
} else {
#if !defined(AARCH64)
ShouldNotReachHere();
#endif
}
} else {
type_name = type2name(type());
if (assigned_reg() != -1 &&
(LinearScan::num_physical_regs(type()) == 1 || assigned_regHi() != -1)) {
opr = LinearScan::calc_operand_for_interval(this);
}
}
out->print("%d %s ", reg_num(), type_name);
if (opr->is_valid()) {
out->print("\"");
opr->print(out);
out->print("\" ");
}
out->print("%d %d ", split_parent()->reg_num(), (register_hint(false) != NULL ? register_hint(false)->reg_num() : -1));
Range* cur = _first;
while (cur != Range::end()) {
cur->print(out);
cur = cur->next();
assert(cur != NULL, "range list not closed with range sentinel");
}
int prev = 0;
assert(_use_pos_and_kinds.length() % 2 == 0, "must be");
for (int i =_use_pos_and_kinds.length() - 2; i >= 0; i -= 2) {
assert(_use_pos_and_kinds.at(i + 1) >= firstValidKind && _use_pos_and_kinds.at(i + 1) <= lastValidKind, "invalid use kind");
assert(prev < _use_pos_and_kinds.at(i), "use positions not sorted");
out->print("%d %s ", _use_pos_and_kinds.at(i), UseKind2Name[_use_pos_and_kinds.at(i + 1)]);
prev = _use_pos_and_kinds.at(i);
}
out->print(" \"%s\"", SpillState2Name[spill_state()]);
out->cr();
}
#endif
IntervalWalker::IntervalWalker(LinearScan* allocator, Interval* unhandled_fixed_first, Interval* unhandled_any_first)
: _compilation(allocator->compilation())
, _allocator(allocator)
{
_unhandled_first[fixedKind] = unhandled_fixed_first;
_unhandled_first[anyKind] = unhandled_any_first;
_active_first[fixedKind] = Interval::end();
_inactive_first[fixedKind] = Interval::end();
_active_first[anyKind] = Interval::end();
_inactive_first[anyKind] = Interval::end();
_current_position = -1;
_current = NULL;
next_interval();
}
void IntervalWalker::append_unsorted(Interval** list, Interval* interval) {
interval->set_next(*list); *list = interval;
}
void IntervalWalker::append_sorted(Interval** list, Interval* interval) {
Interval* prev = NULL;
Interval* cur = *list;
while (cur->current_from() < interval->current_from()) {
prev = cur; cur = cur->next();
}
if (prev == NULL) {
} else {
prev->set_next(interval);
}
interval->set_next(cur);
}
void IntervalWalker::append_to_unhandled(Interval** list, Interval* interval) {
assert(interval->from() >= current()->current_from(), "cannot append new interval before current walk position");
Interval* prev = NULL;
Interval* cur = *list;
while (cur->from() < interval->from() || (cur->from() == interval->from() && cur->first_usage(noUse) < interval->first_usage(noUse))) {
prev = cur; cur = cur->next();
}
if (prev == NULL) {
} else {
prev->set_next(interval);
}
interval->set_next(cur);
}
inline bool IntervalWalker::remove_from_list(Interval** list, Interval* i) {
while (*list != Interval::end() && *list != i) {
list = (*list)->next_addr();
}
if (*list != Interval::end()) {
assert(*list == i, "check");
return true;
} else {
return false;
}
}
void IntervalWalker::remove_from_list(Interval* i) {
bool deleted;
if (i->state() == activeState) {
deleted = remove_from_list(active_first_addr(anyKind), i);
} else {
assert(i->state() == inactiveState, "invalid state");
deleted = remove_from_list(inactive_first_addr(anyKind), i);
}
assert(deleted, "interval has not been found in list");
}
void IntervalWalker::walk_to(IntervalState state, int from) {
assert (state == activeState || state == inactiveState, "wrong state");
for_each_interval_kind(kind) {
Interval** prev = state == activeState ? active_first_addr(kind) : inactive_first_addr(kind);
Interval* next = *prev;
while (next->current_from() <= from) {
Interval* cur = next;
next = cur->next();
bool range_has_changed = false;
while (cur->current_to() <= from) {
cur->next_range();
range_has_changed = true;
}
range_has_changed = range_has_changed || (state == inactiveState && cur->current_from() <= from);
if (range_has_changed) {
if (cur->current_at_end()) {
cur->set_state(handledState);
interval_moved(cur, kind, state, handledState);
} else if (cur->current_from() <= from){
append_sorted(active_first_addr(kind), cur);
cur->set_state(activeState);
if (*prev == cur) {
assert(state == activeState, "check");
prev = cur->next_addr();
}
interval_moved(cur, kind, state, activeState);
} else {
append_sorted(inactive_first_addr(kind), cur);
cur->set_state(inactiveState);
if (*prev == cur) {
assert(state == inactiveState, "check");
prev = cur->next_addr();
}
interval_moved(cur, kind, state, inactiveState);
}
} else {
prev = cur->next_addr();
continue;
}
}
}
}
void IntervalWalker::next_interval() {
IntervalKind kind;
Interval* any = _unhandled_first[anyKind];
Interval* fixed = _unhandled_first[fixedKind];
if (any != Interval::end()) {
kind = fixed != Interval::end() && fixed->from() <= any->from() ? fixedKind : anyKind;
assert (kind == fixedKind && fixed->from() <= any->from() ||
kind == anyKind && any->from() <= fixed->from(), "wrong interval!!!");
assert(any == Interval::end() || fixed == Interval::end() || any->from() != fixed->from() || kind == fixedKind, "if fixed and any-Interval start at same position, fixed must be processed first");
} else if (fixed != Interval::end()) {
kind = fixedKind;
} else {
_current = NULL; return;
}
_current_kind = kind;
_current = _unhandled_first[kind];
_unhandled_first[kind] = _current->next();
_current->set_next(Interval::end());
_current->rewind_range();
}
void IntervalWalker::walk_to(int lir_op_id) {
assert(_current_position <= lir_op_id, "can not walk backwards");
while (current() != NULL) {
bool is_active = current()->from() <= lir_op_id;
int id = is_active ? current()->from() : lir_op_id;
TRACE_LINEAR_SCAN(2, if (_current_position < id) { tty->cr(); tty->print_cr("walk_to(%d) **************************************************************", id); })
_current_position = id;
walk_to(activeState, id);
walk_to(inactiveState, id);
if (is_active) {
current()->set_state(activeState);
if (activate_current()) {
append_sorted(active_first_addr(current_kind()), current());
interval_moved(current(), current_kind(), unhandledState, activeState);
}
next_interval();
} else {
return;
}
}
}
void IntervalWalker::interval_moved(Interval* interval, IntervalKind kind, IntervalState from, IntervalState to) {
#ifndef PRODUCT
if (TraceLinearScanLevel >= 4) {
#define print_state(state) \
switch(state) {\
case unhandledState: tty->print("unhandled"); break;\
case activeState: tty->print("active"); break;\
case inactiveState: tty->print("inactive"); break;\
case handledState: tty->print("handled"); break;\
default: ShouldNotReachHere(); \
}
print_state(from); tty->print(" to "); print_state(to);
tty->fill_to(23);
interval->print();
#undef print_state
}
#endif
}
LinearScanWalker::LinearScanWalker(LinearScan* allocator, Interval* unhandled_fixed_first, Interval* unhandled_any_first)
: IntervalWalker(allocator, unhandled_fixed_first, unhandled_any_first)
, _move_resolver(allocator)
{
for (int i = 0; i < LinearScan::nof_regs; i++) {
_spill_intervals[i] = new IntervalList(2);
}
}
inline void LinearScanWalker::init_use_lists(bool only_process_use_pos) {
for (int i = _first_reg; i <= _last_reg; i++) {
_use_pos[i] = max_jint;
if (!only_process_use_pos) {
_block_pos[i] = max_jint;
_spill_intervals[i]->clear();
}
}
}
inline void LinearScanWalker::exclude_from_use(int reg) {
assert(reg < LinearScan::nof_regs, "interval must have a register assigned (stack slots not allowed)");
if (reg >= _first_reg && reg <= _last_reg) {
_use_pos[reg] = 0;
}
}
inline void LinearScanWalker::exclude_from_use(Interval* i) {
assert(i->assigned_reg() != any_reg, "interval has no register assigned");
exclude_from_use(i->assigned_reg());
exclude_from_use(i->assigned_regHi());
}
inline void LinearScanWalker::set_use_pos(int reg, Interval* i, int use_pos, bool only_process_use_pos) {
assert(use_pos != 0, "must use exclude_from_use to set use_pos to 0");
if (reg >= _first_reg && reg <= _last_reg) {
if (_use_pos[reg] > use_pos) {
_use_pos[reg] = use_pos;
}
if (!only_process_use_pos) {
_spill_intervals[reg]->append(i);
}
}
}
inline void LinearScanWalker::set_use_pos(Interval* i, int use_pos, bool only_process_use_pos) {
assert(i->assigned_reg() != any_reg, "interval has no register assigned");
if (use_pos != -1) {
set_use_pos(i->assigned_reg(), i, use_pos, only_process_use_pos);
set_use_pos(i->assigned_regHi(), i, use_pos, only_process_use_pos);
}
}
inline void LinearScanWalker::set_block_pos(int reg, Interval* i, int block_pos) {
if (reg >= _first_reg && reg <= _last_reg) {
if (_block_pos[reg] > block_pos) {
_block_pos[reg] = block_pos;
}
if (_use_pos[reg] > block_pos) {
_use_pos[reg] = block_pos;
}
}
}
inline void LinearScanWalker::set_block_pos(Interval* i, int block_pos) {
assert(i->assigned_reg() != any_reg, "interval has no register assigned");
if (block_pos != -1) {
set_block_pos(i->assigned_reg(), i, block_pos);
set_block_pos(i->assigned_regHi(), i, block_pos);
}
}
void LinearScanWalker::free_exclude_active_fixed() {
Interval* list = active_first(fixedKind);
while (list != Interval::end()) {
assert(list->assigned_reg() < LinearScan::nof_regs, "active interval must have a register assigned");
exclude_from_use(list);
list = list->next();
}
}
void LinearScanWalker::free_exclude_active_any() {
Interval* list = active_first(anyKind);
while (list != Interval::end()) {
exclude_from_use(list);
list = list->next();
}
}
void LinearScanWalker::free_collect_inactive_fixed(Interval* cur) {
Interval* list = inactive_first(fixedKind);
while (list != Interval::end()) {
if (cur->to() <= list->current_from()) {
assert(list->current_intersects_at(cur) == -1, "must not intersect");
set_use_pos(list, list->current_from(), true);
} else {
set_use_pos(list, list->current_intersects_at(cur), true);
}
list = list->next();
}
}
void LinearScanWalker::free_collect_inactive_any(Interval* cur) {
Interval* list = inactive_first(anyKind);
while (list != Interval::end()) {
set_use_pos(list, list->current_intersects_at(cur), true);
list = list->next();
}
}
void LinearScanWalker::free_collect_unhandled(IntervalKind kind, Interval* cur) {
Interval* list = unhandled_first(kind);
while (list != Interval::end()) {
set_use_pos(list, list->intersects_at(cur), true);
if (kind == fixedKind && cur->to() <= list->from()) {
set_use_pos(list, list->from(), true);
}
list = list->next();
}
}
void LinearScanWalker::spill_exclude_active_fixed() {
Interval* list = active_first(fixedKind);
while (list != Interval::end()) {
exclude_from_use(list);
list = list->next();
}
}
void LinearScanWalker::spill_block_unhandled_fixed(Interval* cur) {
Interval* list = unhandled_first(fixedKind);
while (list != Interval::end()) {
set_block_pos(list, list->intersects_at(cur));
list = list->next();
}
}
void LinearScanWalker::spill_block_inactive_fixed(Interval* cur) {
Interval* list = inactive_first(fixedKind);
while (list != Interval::end()) {
if (cur->to() > list->current_from()) {
set_block_pos(list, list->current_intersects_at(cur));
} else {
assert(list->current_intersects_at(cur) == -1, "invalid optimization: intervals intersect");
}
list = list->next();
}
}
void LinearScanWalker::spill_collect_active_any() {
Interval* list = active_first(anyKind);
while (list != Interval::end()) {
set_use_pos(list, MIN2(list->next_usage(loopEndMarker, _current_position), list->to()), false);
list = list->next();
}
}
void LinearScanWalker::spill_collect_inactive_any(Interval* cur) {
Interval* list = inactive_first(anyKind);
while (list != Interval::end()) {
if (list->current_intersects(cur)) {
set_use_pos(list, MIN2(list->next_usage(loopEndMarker, _current_position), list->to()), false);
}
list = list->next();
}
}
void LinearScanWalker::insert_move(int op_id, Interval* src_it, Interval* dst_it) {
op_id = (op_id + 1) & ~1;
BlockBegin* op_block = allocator()->block_of_op_with_id(op_id);
assert(op_id > 0 && allocator()->block_of_op_with_id(op_id - 2) == op_block, "cannot insert move at block boundary");
LIR_OpList* list = op_block->lir()->instructions_list();
int index = (op_id - list->at(0)->id()) / 2;
assert(list->at(index)->id() <= op_id, "error in calculation");
while (list->at(index)->id() != op_id) {
index++;
assert(0 <= index && index < list->length(), "index out of bounds");
}
assert(1 <= index && index < list->length(), "index out of bounds");
assert(list->at(index)->id() == op_id, "error in calculation");
_move_resolver.move_insert_position(op_block->lir(), index - 1);
_move_resolver.add_mapping(src_it, dst_it);
}
int LinearScanWalker::find_optimal_split_pos(BlockBegin* min_block, BlockBegin* max_block, int max_split_pos) {
int from_block_nr = min_block->linear_scan_number();
int to_block_nr = max_block->linear_scan_number();
assert(0 <= from_block_nr && from_block_nr < block_count(), "out of range");
assert(0 <= to_block_nr && to_block_nr < block_count(), "out of range");
assert(from_block_nr < to_block_nr, "must cross block boundary");
int optimal_split_pos = max_block->last_lir_instruction_id() + 2;
if (optimal_split_pos > max_split_pos) {
optimal_split_pos = max_block->first_lir_instruction_id();
}
int min_loop_depth = max_block->loop_depth();
for (int i = to_block_nr - 1; i >= from_block_nr; i--) {
BlockBegin* cur = block_at(i);
if (cur->loop_depth() < min_loop_depth) {
min_loop_depth = cur->loop_depth();
optimal_split_pos = cur->last_lir_instruction_id() + 2;
}
}
assert(optimal_split_pos > allocator()->max_lir_op_id() || allocator()->is_block_begin(optimal_split_pos), "algorithm must move split pos to block boundary");
return optimal_split_pos;
}
int LinearScanWalker::find_optimal_split_pos(Interval* it, int min_split_pos, int max_split_pos, bool do_loop_optimization) {
int optimal_split_pos = -1;
if (min_split_pos == max_split_pos) {
TRACE_LINEAR_SCAN(4, tty->print_cr(" min-pos and max-pos are equal, no optimization possible"));
optimal_split_pos = min_split_pos;
} else {
assert(min_split_pos < max_split_pos, "must be true then");
assert(min_split_pos > 0, "cannot access min_split_pos - 1 otherwise");
BlockBegin* min_block = allocator()->block_of_op_with_id(min_split_pos - 1);
BlockBegin* max_block = allocator()->block_of_op_with_id(max_split_pos - 1);
assert(min_block->linear_scan_number() <= max_block->linear_scan_number(), "invalid order");
if (min_block == max_block) {
TRACE_LINEAR_SCAN(4, tty->print_cr(" cannot move split pos to block boundary because min_pos and max_pos are in same block"));
optimal_split_pos = max_split_pos;
} else if (it->has_hole_between(max_split_pos - 1, max_split_pos) && !allocator()->is_block_begin(max_split_pos)) {
TRACE_LINEAR_SCAN(4, tty->print_cr(" interval has hole just before max_split_pos, so splitting at max_split_pos"));
optimal_split_pos = max_split_pos;
} else {
TRACE_LINEAR_SCAN(4, tty->print_cr(" moving split pos to optimal block boundary between block B%d and B%d", min_block->block_id(), max_block->block_id()));
if (do_loop_optimization) {
int loop_end_pos = it->next_usage_exact(loopEndMarker, min_block->last_lir_instruction_id() + 2);
TRACE_LINEAR_SCAN(4, tty->print_cr(" loop optimization: loop end found at pos %d", loop_end_pos));
assert(loop_end_pos > min_split_pos, "invalid order");
if (loop_end_pos < max_split_pos) {
BlockBegin* loop_block = allocator()->block_of_op_with_id(loop_end_pos);
TRACE_LINEAR_SCAN(4, tty->print_cr(" interval is used in loop that ends in block B%d, so trying to move max_block back from B%d to B%d", loop_block->block_id(), max_block->block_id(), loop_block->block_id()));
assert(loop_block != min_block, "loop_block and min_block must be different because block boundary is needed between");
optimal_split_pos = find_optimal_split_pos(min_block, loop_block, loop_block->last_lir_instruction_id() + 2);
if (optimal_split_pos == loop_block->last_lir_instruction_id() + 2) {
optimal_split_pos = -1;
TRACE_LINEAR_SCAN(4, tty->print_cr(" loop optimization not necessary"));
} else {
TRACE_LINEAR_SCAN(4, tty->print_cr(" loop optimization successful"));
}
}
}
if (optimal_split_pos == -1) {
optimal_split_pos = find_optimal_split_pos(min_block, max_block, max_split_pos);
}
}
}
TRACE_LINEAR_SCAN(4, tty->print_cr(" optimal split position: %d", optimal_split_pos));
return optimal_split_pos;
}
split an interval at the optimal position between min_split_pos and
max_split_pos in two parts:
1) the left part has already a location assigned
2) the right part is sorted into to the unhandled-list
void LinearScanWalker::split_before_usage(Interval* it, int min_split_pos, int max_split_pos) {
TRACE_LINEAR_SCAN(2, tty->print ("----- splitting interval: "); it->print());
TRACE_LINEAR_SCAN(2, tty->print_cr(" between %d and %d", min_split_pos, max_split_pos));
assert(it->from() < min_split_pos, "cannot split at start of interval");
assert(current_position() < min_split_pos, "cannot split before current position");
assert(min_split_pos <= max_split_pos, "invalid order");
assert(max_split_pos <= it->to(), "cannot split after end of interval");
int optimal_split_pos = find_optimal_split_pos(it, min_split_pos, max_split_pos, true);
assert(min_split_pos <= optimal_split_pos && optimal_split_pos <= max_split_pos, "out of range");
assert(optimal_split_pos <= it->to(), "cannot split after end of interval");
assert(optimal_split_pos > it->from(), "cannot split at start of interval");
if (optimal_split_pos == it->to() && it->next_usage(mustHaveRegister, min_split_pos) == max_jint) {
TRACE_LINEAR_SCAN(4, tty->print_cr(" no split necessary because optimal split position is at end of interval"));
return;
}
bool move_necessary = !allocator()->is_block_begin(optimal_split_pos) && !it->has_hole_between(optimal_split_pos - 1, optimal_split_pos);
if (!allocator()->is_block_begin(optimal_split_pos)) {
optimal_split_pos = (optimal_split_pos - 1) | 1;
}
TRACE_LINEAR_SCAN(4, tty->print_cr(" splitting at position %d", optimal_split_pos));
assert(allocator()->is_block_begin(optimal_split_pos) || (optimal_split_pos % 2 == 1), "split pos must be odd when not on block boundary");
assert(!allocator()->is_block_begin(optimal_split_pos) || (optimal_split_pos % 2 == 0), "split pos must be even on block boundary");
Interval* split_part = it->split(optimal_split_pos);
allocator()->append_interval(split_part);
allocator()->copy_register_flags(it, split_part);
split_part->set_insert_move_when_activated(move_necessary);
append_to_unhandled(unhandled_first_addr(anyKind), split_part);
TRACE_LINEAR_SCAN(2, tty->print_cr(" split interval in two parts (insert_move_when_activated: %d)", move_necessary));
TRACE_LINEAR_SCAN(2, tty->print (" "); it->print());
TRACE_LINEAR_SCAN(2, tty->print (" "); split_part->print());
}
split an interval at the optimal position between min_split_pos and
max_split_pos in two parts:
1) the left part has already a location assigned
2) the right part is always on the stack and therefore ignored in further processing
void LinearScanWalker::split_for_spilling(Interval* it) {
int max_split_pos = current_position();
int min_split_pos = MAX2(it->previous_usage(shouldHaveRegister, max_split_pos) + 1, it->from());
TRACE_LINEAR_SCAN(2, tty->print ("----- splitting and spilling interval: "); it->print());
TRACE_LINEAR_SCAN(2, tty->print_cr(" between %d and %d", min_split_pos, max_split_pos));
assert(it->state() == activeState, "why spill interval that is not active?");
assert(it->from() <= min_split_pos, "cannot split before start of interval");
assert(min_split_pos <= max_split_pos, "invalid order");
assert(max_split_pos < it->to(), "cannot split at end end of interval");
assert(current_position() < it->to(), "interval must not end before current position");
if (min_split_pos == it->from()) {
TRACE_LINEAR_SCAN(2, tty->print_cr(" spilling entire interval because split pos is at beginning of interval"));
assert(it->first_usage(shouldHaveRegister) > current_position(), "interval must not have use position before current_position");
allocator()->assign_spill_slot(it);
allocator()->change_spill_state(it, min_split_pos);
Interval* parent = it;
while (parent != NULL && parent->is_split_child()) {
parent = parent->split_child_before_op_id(parent->from());
if (parent->assigned_reg() < LinearScan::nof_regs) {
if (parent->first_usage(shouldHaveRegister) == max_jint) {
TRACE_LINEAR_SCAN(4, tty->print_cr(" kicking out interval %d out of its register because it is never used", parent->reg_num()));
allocator()->assign_spill_slot(parent);
} else {
parent = NULL;
}
}
}
} else {
int optimal_split_pos = find_optimal_split_pos(it, min_split_pos, max_split_pos, false);
assert(min_split_pos <= optimal_split_pos && optimal_split_pos <= max_split_pos, "out of range");
assert(optimal_split_pos < it->to(), "cannot split at end of interval");
assert(optimal_split_pos >= it->from(), "cannot split before start of interval");
if (!allocator()->is_block_begin(optimal_split_pos)) {
optimal_split_pos = (optimal_split_pos - 1) | 1;
}
TRACE_LINEAR_SCAN(4, tty->print_cr(" splitting at position %d", optimal_split_pos));
assert(allocator()->is_block_begin(optimal_split_pos) || (optimal_split_pos % 2 == 1), "split pos must be odd when not on block boundary");
assert(!allocator()->is_block_begin(optimal_split_pos) || (optimal_split_pos % 2 == 0), "split pos must be even on block boundary");
Interval* spilled_part = it->split(optimal_split_pos);
allocator()->append_interval(spilled_part);
allocator()->assign_spill_slot(spilled_part);
allocator()->change_spill_state(spilled_part, optimal_split_pos);
if (!allocator()->is_block_begin(optimal_split_pos)) {
TRACE_LINEAR_SCAN(4, tty->print_cr(" inserting move from interval %d to %d", it->reg_num(), spilled_part->reg_num()));
insert_move(optimal_split_pos, it, spilled_part);
}
assert(spilled_part->current_split_child() == it, "overwriting wrong current_split_child");
spilled_part->make_current_split_child();
TRACE_LINEAR_SCAN(2, tty->print_cr(" split interval in two parts"));
TRACE_LINEAR_SCAN(2, tty->print (" "); it->print());
TRACE_LINEAR_SCAN(2, tty->print (" "); spilled_part->print());
}
}
void LinearScanWalker::split_stack_interval(Interval* it) {
int min_split_pos = current_position() + 1;
int max_split_pos = MIN2(it->first_usage(shouldHaveRegister), it->to());
split_before_usage(it, min_split_pos, max_split_pos);
}
void LinearScanWalker::split_when_partial_register_available(Interval* it, int register_available_until) {
int min_split_pos = MAX2(it->previous_usage(shouldHaveRegister, register_available_until), it->from() + 1);
int max_split_pos = register_available_until;
split_before_usage(it, min_split_pos, max_split_pos);
}
void LinearScanWalker::split_and_spill_interval(Interval* it) {
assert(it->state() == activeState || it->state() == inactiveState, "other states not allowed");
int current_pos = current_position();
if (it->state() == inactiveState) {
assert(it->has_hole_between(current_pos - 1, current_pos + 1), "interval can not be inactive otherwise");
split_before_usage(it, current_pos + 1, current_pos + 1);
} else {
int min_split_pos = current_pos + 1;
int max_split_pos = MIN2(it->next_usage(mustHaveRegister, min_split_pos), it->to());
split_before_usage(it, min_split_pos, max_split_pos);
assert(it->next_usage(mustHaveRegister, current_pos) == max_jint, "the remaining part is spilled to stack and therefore has no register");
split_for_spilling(it);
}
}
int LinearScanWalker::find_free_reg(int reg_needed_until, int interval_to, int hint_reg, int ignore_reg, bool* need_split) {
int min_full_reg = any_reg;
int max_partial_reg = any_reg;
for (int i = _first_reg; i <= _last_reg; i++) {
if (i == ignore_reg) {
} else if (_use_pos[i] >= interval_to) {
if (min_full_reg == any_reg || i == hint_reg || (_use_pos[i] < _use_pos[min_full_reg] && min_full_reg != hint_reg)) {
min_full_reg = i;
}
} else if (_use_pos[i] > reg_needed_until) {
if (max_partial_reg == any_reg || i == hint_reg || (_use_pos[i] > _use_pos[max_partial_reg] && max_partial_reg != hint_reg)) {
max_partial_reg = i;
}
}
}
if (min_full_reg != any_reg) {
return min_full_reg;
} else if (max_partial_reg != any_reg) {
return max_partial_reg;
} else {
return any_reg;
}
}
int LinearScanWalker::find_free_double_reg(int reg_needed_until, int interval_to, int hint_reg, bool* need_split) {
assert((_last_reg - _first_reg + 1) % 2 == 0, "adjust algorithm");
int min_full_reg = any_reg;
int max_partial_reg = any_reg;
for (int i = _first_reg; i < _last_reg; i+=2) {
if (_use_pos[i] >= interval_to && _use_pos[i + 1] >= interval_to) {
if (min_full_reg == any_reg || i == hint_reg || (_use_pos[i] < _use_pos[min_full_reg] && min_full_reg != hint_reg)) {
min_full_reg = i;
}
} else if (_use_pos[i] > reg_needed_until && _use_pos[i + 1] > reg_needed_until) {
if (max_partial_reg == any_reg || i == hint_reg || (_use_pos[i] > _use_pos[max_partial_reg] && max_partial_reg != hint_reg)) {
max_partial_reg = i;
}
}
}
if (min_full_reg != any_reg) {
return min_full_reg;
} else if (max_partial_reg != any_reg) {
return max_partial_reg;
} else {
return any_reg;
}
}
bool LinearScanWalker::alloc_free_reg(Interval* cur) {
TRACE_LINEAR_SCAN(2, tty->print("trying to find free register for "); cur->print());
init_use_lists(true);
free_exclude_active_fixed();
free_exclude_active_any();
free_collect_inactive_fixed(cur);
free_collect_inactive_any(cur);
assert(unhandled_first(fixedKind) == Interval::end(), "must not have unhandled fixed intervals because all fixed intervals have a use at position 0");
TRACE_LINEAR_SCAN(4, tty->print_cr(" state of registers:"));
TRACE_LINEAR_SCAN(4, for (int i = _first_reg; i <= _last_reg; i++) tty->print_cr(" reg %d: use_pos: %d", i, _use_pos[i]));
int hint_reg, hint_regHi;
Interval* register_hint = cur->register_hint();
if (register_hint != NULL) {
hint_reg = register_hint->assigned_reg();
hint_regHi = register_hint->assigned_regHi();
if (allocator()->is_precolored_cpu_interval(register_hint)) {
assert(hint_reg != any_reg && hint_regHi == any_reg, "must be for fixed intervals");
hint_regHi = hint_reg + 1; // connect e.g. eax-edx
}
TRACE_LINEAR_SCAN(4, tty->print(" hint registers %d, %d from interval ", hint_reg, hint_regHi); register_hint->print());
} else {
hint_reg = any_reg;
hint_regHi = any_reg;
}
assert(hint_reg == any_reg || hint_reg != hint_regHi, "hint reg and regHi equal");
assert(cur->assigned_reg() == any_reg && cur->assigned_regHi() == any_reg, "register already assigned to interval");
int reg_needed_until = cur->from() + 1;
int interval_to = cur->to();
bool need_split = false;
int split_pos = -1;
int reg = any_reg;
int regHi = any_reg;
if (_adjacent_regs) {
reg = find_free_double_reg(reg_needed_until, interval_to, hint_reg, &need_split);
regHi = reg + 1;
if (reg == any_reg) {
return false;
}
split_pos = MIN2(_use_pos[reg], _use_pos[regHi]);
} else {
reg = find_free_reg(reg_needed_until, interval_to, hint_reg, any_reg, &need_split);
if (reg == any_reg) {
return false;
}
split_pos = _use_pos[reg];
if (_num_phys_regs == 2) {
regHi = find_free_reg(reg_needed_until, interval_to, hint_regHi, reg, &need_split);
if (_use_pos[reg] < interval_to && regHi == any_reg) {
return false;
} else if (regHi != any_reg) {
split_pos = MIN2(split_pos, _use_pos[regHi]);
if (reg > regHi) {
int temp = reg;
reg = regHi;
regHi = temp;
}
}
}
}
cur->assign_reg(reg, regHi);
TRACE_LINEAR_SCAN(2, tty->print_cr("selected register %d, %d", reg, regHi));
assert(split_pos > 0, "invalid split_pos");
if (need_split) {
split_when_partial_register_available(cur, split_pos);
}
return _num_phys_regs == 1 || regHi != any_reg;
}
int LinearScanWalker::find_locked_reg(int reg_needed_until, int interval_to, int hint_reg, int ignore_reg, bool* need_split) {
int max_reg = any_reg;
for (int i = _first_reg; i <= _last_reg; i++) {
if (i == ignore_reg) {
} else if (_use_pos[i] > reg_needed_until) {
if (max_reg == any_reg || i == hint_reg || (_use_pos[i] > _use_pos[max_reg] && max_reg != hint_reg)) {
max_reg = i;
}
}
}
if (max_reg != any_reg && _block_pos[max_reg] <= interval_to) {
}
return max_reg;
}
int LinearScanWalker::find_locked_double_reg(int reg_needed_until, int interval_to, int hint_reg, bool* need_split) {
assert((_last_reg - _first_reg + 1) % 2 == 0, "adjust algorithm");
int max_reg = any_reg;
for (int i = _first_reg; i < _last_reg; i+=2) {
if (_use_pos[i] > reg_needed_until && _use_pos[i + 1] > reg_needed_until) {
if (max_reg == any_reg || _use_pos[i] > _use_pos[max_reg]) {
max_reg = i;
}
}
}
if (_block_pos[max_reg] <= interval_to || _block_pos[max_reg + 1] <= interval_to) {
}
return max_reg;
}
void LinearScanWalker::split_and_spill_intersecting_intervals(int reg, int regHi) {
assert(reg != any_reg, "no register assigned");
for (int i = 0; i < _spill_intervals[reg]->length(); i++) {
Interval* it = _spill_intervals[reg]->at(i);
remove_from_list(it);
split_and_spill_interval(it);
}
if (regHi != any_reg) {
IntervalList* processed = _spill_intervals[reg];
for (int i = 0; i < _spill_intervals[regHi]->length(); i++) {
Interval* it = _spill_intervals[regHi]->at(i);
if (processed->index_of(it) == -1) {
remove_from_list(it);
split_and_spill_interval(it);
}
}
}
}
void LinearScanWalker::alloc_locked_reg(Interval* cur) {
TRACE_LINEAR_SCAN(2, tty->print("need to split and spill to get register for "); cur->print());
init_use_lists(false);
spill_exclude_active_fixed();
assert(unhandled_first(fixedKind) == Interval::end(), "must not have unhandled fixed intervals because all fixed intervals have a use at position 0");
spill_block_inactive_fixed(cur);
spill_collect_active_any();
spill_collect_inactive_any(cur);
#ifndef PRODUCT
if (TraceLinearScanLevel >= 4) {
tty->print_cr(" state of registers:");
for (int i = _first_reg; i <= _last_reg; i++) {
tty->print(" reg %d: use_pos: %d, block_pos: %d, intervals: ", i, _use_pos[i], _block_pos[i]);
for (int j = 0; j < _spill_intervals[i]->length(); j++) {
tty->print("%d ", _spill_intervals[i]->at(j)->reg_num());
}
tty->cr();
}
}
#endif
int reg_needed_until = MIN2(cur->first_usage(mustHaveRegister), cur->from() + 1);
int interval_to = cur->to();
assert (reg_needed_until > 0 && reg_needed_until < max_jint, "interval has no use");
int split_pos = 0;
int use_pos = 0;
bool need_split = false;
int reg, regHi;
if (_adjacent_regs) {
reg = find_locked_double_reg(reg_needed_until, interval_to, any_reg, &need_split);
regHi = reg + 1;
if (reg != any_reg) {
use_pos = MIN2(_use_pos[reg], _use_pos[regHi]);
split_pos = MIN2(_block_pos[reg], _block_pos[regHi]);
}
} else {
reg = find_locked_reg(reg_needed_until, interval_to, any_reg, cur->assigned_reg(), &need_split);
regHi = any_reg;
if (reg != any_reg) {
use_pos = _use_pos[reg];
split_pos = _block_pos[reg];
if (_num_phys_regs == 2) {
if (cur->assigned_reg() != any_reg) {
regHi = reg;
reg = cur->assigned_reg();
} else {
regHi = find_locked_reg(reg_needed_until, interval_to, any_reg, reg, &need_split);
if (regHi != any_reg) {
use_pos = MIN2(use_pos, _use_pos[regHi]);
split_pos = MIN2(split_pos, _block_pos[regHi]);
}
}
if (regHi != any_reg && reg > regHi) {
int temp = reg;
reg = regHi;
regHi = temp;
}
}
}
}
if (reg == any_reg || (_num_phys_regs == 2 && regHi == any_reg) || use_pos <= cur->first_usage(mustHaveRegister)) {
TRACE_LINEAR_SCAN(4, tty->print_cr("able to spill current interval. first_usage(register): %d, use_pos: %d", cur->first_usage(mustHaveRegister), use_pos));
if (cur->first_usage(mustHaveRegister) <= cur->from() + 1) {
assert(false, "cannot spill interval that is used in first instruction (possible reason: no register found)");
allocator()->assign_spill_slot(cur);
BAILOUT("LinearScan: no register found");
}
split_and_spill_interval(cur);
} else {
TRACE_LINEAR_SCAN(4, tty->print_cr("decided to use register %d, %d", reg, regHi));
assert(reg != any_reg && (_num_phys_regs == 1 || regHi != any_reg), "no register found");
assert(split_pos > 0, "invalid split_pos");
assert(need_split == false || split_pos > cur->from(), "splitting interval at from");
cur->assign_reg(reg, regHi);
if (need_split) {
split_when_partial_register_available(cur, split_pos);
}
split_and_spill_intersecting_intervals(reg, regHi);
}
}
bool LinearScanWalker::no_allocation_possible(Interval* cur) {
#if defined(X86)
int pos = cur->from();
if ((pos & 1) == 1) {
if (pos < allocator()->max_lir_op_id() && allocator()->has_call(pos + 1)) {
TRACE_LINEAR_SCAN(4, tty->print_cr(" free register cannot be available because all registers blocked by following call"));
assert(alloc_free_reg(cur) == false, "found a register for this interval");
return true;
}
}
#endif
return false;
}
sssssss6
最新推荐文章于 2024-09-08 10:25:07 发布