--- a/hotspot/src/share/vm/c1/c1_Instruction.hpp Wed Sep 22 23:51:03 2010 -0700
+++ b/hotspot/src/share/vm/c1/c1_Instruction.hpp Tue Dec 29 19:08:54 2009 +0100
@@ -38,7 +38,6 @@
// serve factoring.
class Instruction;
-class HiWord;
class Phi;
class Local;
class Constant;
@@ -149,7 +148,6 @@
class InstructionVisitor: public StackObj {
public:
- void do_HiWord (HiWord* x) { ShouldNotReachHere(); }
virtual void do_Phi (Phi* x) = 0;
virtual void do_Local (Local* x) = 0;
virtual void do_Constant (Constant* x) = 0;
@@ -272,7 +270,9 @@
class Instruction: public CompilationResourceObj {
private:
int _id; // the unique instruction id
- int _bci; // the instruction bci
+#ifndef PRODUCT
+ int _printable_bci; // the bci of the instruction for printing
+#endif
int _use_count; // the number of instructions refering to this value (w/o prev/next); only roots can have use count = 0 or > 1
int _pin_state; // set of PinReason describing the reason for pinning
ValueType* _type; // the instruction value type
@@ -281,17 +281,18 @@
LIR_Opr _operand; // LIR specific information
unsigned int _flags; // Flag bits
+ ValueStack* _state_before; // Copy of state with input operands still on stack (or NULL)
+ ValueStack* _exception_state; // Copy of state for exception handling
XHandlers* _exception_handlers; // Flat list of exception handlers covering this instruction
-#ifdef ASSERT
- HiWord* _hi_word;
-#endif
-
friend class UseCountComputer;
friend class BlockBegin;
+ void update_exception_state(ValueStack* state);
+
+ bool has_printable_bci() const { return NOT_PRODUCT(_printable_bci != -99) PRODUCT_ONLY(false); }
+
protected:
- void set_bci(int bci) { assert(bci == SynchronizationEntryBCI || bci >= 0, "illegal bci"); _bci = bci; }
void set_type(ValueType* type) {
assert(type != NULL, "type must exist");
_type = type;
@@ -325,6 +326,7 @@
NeedsPatchingFlag,
ThrowIncompatibleClassChangeErrorFlag,
ProfileMDOFlag,
+ IsLinkedInBlockFlag,
InstructionLastFlag
};
@@ -356,31 +358,31 @@
}
// creation
- Instruction(ValueType* type, bool type_is_constant = false, bool create_hi = true)
- : _bci(-99)
- , _use_count(0)
+ Instruction(ValueType* type, ValueStack* state_before = NULL, bool type_is_constant = false, bool create_hi = true)
+ : _use_count(0)
+#ifndef PRODUCT
+ , _printable_bci(-99)
+#endif
, _pin_state(0)
, _type(type)
, _next(NULL)
, _subst(NULL)
, _flags(0)
, _operand(LIR_OprFact::illegalOpr)
+ , _state_before(state_before)
, _exception_handlers(NULL)
-#ifdef ASSERT
- , _hi_word(NULL)
-#endif
{
+ check_state(state_before);
assert(type != NULL && (!type->is_constant() || type_is_constant), "type must exist");
-#ifdef ASSERT
- if (create_hi && type->is_double_word()) {
- create_hi_word();
- }
-#endif
+ update_exception_state(_state_before);
}
// accessors
int id() const { return _id; }
- int bci() const { return _bci; }
+#ifndef PRODUCT
+ int printable_bci() const { assert(has_printable_bci(), "_printable_bci should have been set"); return _printable_bci; }
+ void set_printable_bci(int bci) { NOT_PRODUCT(_printable_bci = bci;) }
+#endif
int use_count() const { return _use_count; }
int pin_state() const { return _pin_state; }
bool is_pinned() const { return _pin_state != 0 || PinAllInstructions; }
@@ -393,9 +395,13 @@
void set_needs_null_check(bool f) { set_flag(NeedsNullCheckFlag, f); }
bool needs_null_check() const { return check_flag(NeedsNullCheckFlag); }
+ bool is_linked() const { return check_flag(IsLinkedInBlockFlag); }
+ bool can_be_linked() { return as_Local() == NULL && as_Phi() == NULL; }
bool has_uses() const { return use_count() > 0; }
- bool is_root() const { return is_pinned() || use_count() > 1; }
+ ValueStack* state_before() const { return _state_before; }
+ ValueStack* exception_state() const { return _exception_state; }
+ virtual bool needs_exception_state() const { return true; }
XHandlers* exception_handlers() const { return _exception_handlers; }
// manipulation
@@ -403,17 +409,23 @@
void pin() { _pin_state |= PinUnknown; }
// DANGEROUS: only used by EliminateStores
void unpin(PinReason reason) { assert((reason & PinUnknown) == 0, "can't unpin unknown state"); _pin_state &= ~reason; }
- virtual void set_lock_stack(ValueStack* l) { /* do nothing*/ }
- virtual ValueStack* lock_stack() const { return NULL; }
+
+ Instruction* set_next(Instruction* next) {
+ assert(next->has_printable_bci(), "_printable_bci should have been set");
+ assert(next != NULL, "must not be NULL");
+ assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no next");
+ assert(next->can_be_linked(), "shouldn't link these instructions into list");
+
+ next->set_flag(Instruction::IsLinkedInBlockFlag, true);
+ _next = next;
+ return next;
+ }
Instruction* set_next(Instruction* next, int bci) {
- if (next != NULL) {
- assert(as_BlockEnd() == NULL, "BlockEnd instructions must have no next");
- assert(next->as_Phi() == NULL && next->as_Local() == NULL, "shouldn't link these instructions into list");
- next->set_bci(bci);
- }
- _next = next;
- return next;
+#ifndef PRODUCT
+ next->set_printable_bci(bci);
+#endif
+ return set_next(next);
}
void set_subst(Instruction* subst) {
@@ -423,14 +435,7 @@
_subst = subst;
}
void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
-
-#ifdef ASSERT
- // HiWord is used for debugging and is allocated early to avoid
- // allocation at inconvenient points
- HiWord* hi_word() { return _hi_word; }
- void create_hi_word();
-#endif
-
+ void set_exception_state(ValueStack* s) { check_state(s); _exception_state = s; }
// machine-specifics
void set_operand(LIR_Opr operand) { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }
@@ -438,7 +443,6 @@
// generic
virtual Instruction* as_Instruction() { return this; } // to satisfy HASHING1 macro
- virtual HiWord* as_HiWord() { return NULL; }
virtual Phi* as_Phi() { return NULL; }
virtual Local* as_Local() { return NULL; }
virtual Constant* as_Constant() { return NULL; }
@@ -493,7 +497,7 @@
virtual bool can_trap() const { return false; }
virtual void input_values_do(ValueVisitor* f) = 0;
- virtual void state_values_do(ValueVisitor* f) { /* usually no state - override on demand */ }
+ virtual void state_values_do(ValueVisitor* f);
virtual void other_values_do(ValueVisitor* f) { /* usually no other - override on demand */ }
void values_do(ValueVisitor* f) { input_values_do(f); state_values_do(f); other_values_do(f); }
@@ -505,6 +509,7 @@
HASHING1(Instruction, false, id()) // hashing disabled by default
// debugging
+ static void check_state(ValueStack* state) PRODUCT_RETURN;
void print() PRODUCT_RETURN;
void print_line() PRODUCT_RETURN;
void print(InstructionPrinter& ip) PRODUCT_RETURN;
@@ -541,40 +546,6 @@
#endif // ASSERT
-// A HiWord occupies the 'high word' of a 2-word
-// expression stack entry. Hi & lo words must be
-// paired on the expression stack (otherwise the
-// bytecode sequence is illegal). Note that 'hi'
-// refers to the IR expression stack format and
-// does *not* imply a machine word ordering. No
-// HiWords are used in optimized mode for speed,
-// but NULL pointers are used instead.
-
-LEAF(HiWord, Instruction)
- private:
- Value _lo_word;
-
- public:
- // creation
- HiWord(Value lo_word)
- : Instruction(illegalType, false, false),
- _lo_word(lo_word) {
- // hi-words are also allowed for illegal lo-words
- assert(lo_word->type()->is_double_word() || lo_word->type()->is_illegal(),
- "HiWord must be used for 2-word values only");
- }
-
- // accessors
- Value lo_word() const { return _lo_word->subst(); }
-
- // for invalidating of HiWords
- void make_illegal() { set_type(illegalType); }
-
- // generic
- virtual void input_values_do(ValueVisitor* f) { ShouldNotReachHere(); }
-};
-
-
// A Phi is a phi function in the sense of SSA form. It stands for
// the value of a local variable at the beginning of a join block.
// A Phi consists of n operands, one for every incoming branch.
@@ -656,31 +627,25 @@
LEAF(Constant, Instruction)
- ValueStack* _state;
-
public:
// creation
Constant(ValueType* type):
- Instruction(type, true)
- , _state(NULL) {
+ Instruction(type, NULL, true)
+ {
assert(type->is_constant(), "must be a constant");
}
- Constant(ValueType* type, ValueStack* state):
- Instruction(type, true)
- , _state(state) {
- assert(state != NULL, "only used for constants which need patching");
+ Constant(ValueType* type, ValueStack* state_before):
+ Instruction(type, state_before, true)
+ {
+ assert(state_before != NULL, "only used for constants which need patching");
assert(type->is_constant(), "must be a constant");
// since it's patching it needs to be pinned
pin();
}
- ValueStack* state() const { return _state; }
-
- // generic
- virtual bool can_trap() const { return state() != NULL; }
+ virtual bool can_trap() const { return state_before() != NULL; }
virtual void input_values_do(ValueVisitor* f) { /* no values */ }
- virtual void other_values_do(ValueVisitor* f);
virtual intx hash() const;
virtual bool is_equal(Value v) const;
@@ -695,20 +660,16 @@
Value _obj;
int _offset;
ciField* _field;
- ValueStack* _state_before; // state is set only for unloaded or uninitialized fields
- ValueStack* _lock_stack; // contains lock and scope information
NullCheck* _explicit_null_check; // For explicit null check elimination
public:
// creation
- AccessField(Value obj, int offset, ciField* field, bool is_static, ValueStack* lock_stack,
+ AccessField(Value obj, int offset, ciField* field, bool is_static,
ValueStack* state_before, bool is_loaded, bool is_initialized)
- : Instruction(as_ValueType(field->type()->basic_type()))
+ : Instruction(as_ValueType(field->type()->basic_type()), state_before)
, _obj(obj)
, _offset(offset)
, _field(field)
- , _lock_stack(lock_stack)
- , _state_before(state_before)
, _explicit_null_check(NULL)
{
set_needs_null_check(!is_static);
@@ -734,13 +695,11 @@
bool is_static() const { return check_flag(IsStaticFlag); }
bool is_loaded() const { return check_flag(IsLoadedFlag); }
bool is_initialized() const { return check_flag(IsInitializedFlag); }
- ValueStack* state_before() const { return _state_before; }
- ValueStack* lock_stack() const { return _lock_stack; }
NullCheck* explicit_null_check() const { return _explicit_null_check; }
bool needs_patching() const { return check_flag(NeedsPatchingFlag); }
// manipulation
- void set_lock_stack(ValueStack* l) { _lock_stack = l; }
+
// Under certain circumstances, if a previous NullCheck instruction
// proved the target object non-null, we can eliminate the explicit
// null check and do an implicit one, simply specifying the debug
@@ -751,16 +710,15 @@
// generic
virtual bool can_trap() const { return needs_null_check() || needs_patching(); }
virtual void input_values_do(ValueVisitor* f) { f->visit(&_obj); }
- virtual void other_values_do(ValueVisitor* f);
};
LEAF(LoadField, AccessField)
public:
// creation
- LoadField(Value obj, int offset, ciField* field, bool is_static, ValueStack* lock_stack,
+ LoadField(Value obj, int offset, ciField* field, bool is_static,
ValueStack* state_before, bool is_loaded, bool is_initialized)
- : AccessField(obj, offset, field, is_static, lock_stack, state_before, is_loaded, is_initialized)
+ : AccessField(obj, offset, field, is_static, state_before, is_loaded, is_initialized)
{}
ciType* declared_type() const;
@@ -777,9 +735,9 @@
public:
// creation
- StoreField(Value obj, int offset, ciField* field, Value value, bool is_static, ValueStack* lock_stack,
+ StoreField(Value obj, int offset, ciField* field, Value value, bool is_static,
ValueStack* state_before, bool is_loaded, bool is_initialized)
- : AccessField(obj, offset, field, is_static, lock_stack, state_before, is_loaded, is_initialized)
+ : AccessField(obj, offset, field, is_static, state_before, is_loaded, is_initialized)
, _value(value)
{
set_flag(NeedsWriteBarrierFlag, as_ValueType(field_type())->is_object());
@@ -799,29 +757,23 @@
BASE(AccessArray, Instruction)
private:
Value _array;
- ValueStack* _lock_stack;
public:
// creation
- AccessArray(ValueType* type, Value array, ValueStack* lock_stack)
- : Instruction(type)
+ AccessArray(ValueType* type, Value array, ValueStack* state_before)
+ : Instruction(type, state_before)
, _array(array)
- , _lock_stack(lock_stack) {
+ {
set_needs_null_check(true);
ASSERT_VALUES
pin(); // instruction with side effect (null exception or range check throwing)
}
Value array() const { return _array; }
- ValueStack* lock_stack() const { return _lock_stack; }
-
- // setters
- void set_lock_stack(ValueStack* l) { _lock_stack = l; }
// generic
virtual bool can_trap() const { return needs_null_check(); }
virtual void input_values_do(ValueVisitor* f) { f->visit(&_array); }
- virtual void other_values_do(ValueVisitor* f);
};
@@ -831,8 +783,8 @@
public:
// creation
- ArrayLength(Value array, ValueStack* lock_stack)
- : AccessArray(intType, array, lock_stack)
+ ArrayLength(Value array, ValueStack* state_before)
+ : AccessArray(intType, array, state_before)
, _explicit_null_check(NULL) {}
// accessors
@@ -855,8 +807,8 @@
public:
// creation
- AccessIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* lock_stack)
- : AccessArray(as_ValueType(elt_type), array, lock_stack)
+ AccessIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before)
+ : AccessArray(as_ValueType(elt_type), array, state_before)
, _index(index)
, _length(length)
, _elt_type(elt_type)
@@ -883,8 +835,8 @@
public:
// creation
- LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* lock_stack)
- : AccessIndexed(array, index, length, elt_type, lock_stack)
+ LoadIndexed(Value array, Value index, Value length, BasicType elt_type, ValueStack* state_before)
+ : AccessIndexed(array, index, length, elt_type, state_before)
, _explicit_null_check(NULL) {}
// accessors
@@ -910,8 +862,8 @@
int _profiled_bci;
public:
// creation
- StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* lock_stack)
- : AccessIndexed(array, index, length, elt_type, lock_stack)
+ StoreIndexed(Value array, Value index, Value length, BasicType elt_type, Value value, ValueStack* state_before)
+ : AccessIndexed(array, index, length, elt_type, state_before)
, _value(value), _profiled_method(NULL), _profiled_bci(0)
{
set_flag(NeedsWriteBarrierFlag, (as_ValueType(elt_type)->is_object()));
@@ -922,7 +874,6 @@
// accessors
Value value() const { return _value; }
- IRScope* scope() const; // the state's scope
bool needs_write_barrier() const { return check_flag(NeedsWriteBarrierFlag); }
bool needs_store_check() const { return check_flag(NeedsStoreCheckFlag); }
// Helpers for methodDataOop profiling
@@ -963,7 +914,12 @@
public:
// creation
- Op2(ValueType* type, Bytecodes::Code op, Value x, Value y) : Instruction(type), _op(op), _x(x), _y(y) {
+ Op2(ValueType* type, Bytecodes::Code op, Value x, Value y, ValueStack* state_before = NULL)
+ : Instruction(type, state_before)
+ , _op(op)
+ , _x(x)
+ , _y(y)
+ {
ASSERT_VALUES
}
@@ -985,28 +941,21 @@
LEAF(ArithmeticOp, Op2)
- private:
- ValueStack* _lock_stack; // used only for division operations
public:
// creation
- ArithmeticOp(Bytecodes::Code op, Value x, Value y, bool is_strictfp, ValueStack* lock_stack)
- : Op2(x->type()->meet(y->type()), op, x, y)
- , _lock_stack(lock_stack) {
+ ArithmeticOp(Bytecodes::Code op, Value x, Value y, bool is_strictfp, ValueStack* state_before)
+ : Op2(x->type()->meet(y->type()), op, x, y, state_before)
+ {
set_flag(IsStrictfpFlag, is_strictfp);
if (can_trap()) pin();
}
// accessors
- ValueStack* lock_stack() const { return _lock_stack; }
bool is_strictfp() const { return check_flag(IsStrictfpFlag); }
- // setters
- void set_lock_stack(ValueStack* l) { _lock_stack = l; }
-
// generic
virtual bool is_commutative() const;
virtual bool can_trap() const;
- virtual void other_values_do(ValueVisitor* f);
HASHING3(Op2, true, op(), x()->subst(), y()->subst())
};
@@ -1033,21 +982,14 @@
LEAF(CompareOp, Op2)
- private:
- ValueStack* _state_before; // for deoptimization, when canonicalizing
public:
// creation
CompareOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
- : Op2(intType, op, x, y)
- , _state_before(state_before)
+ : Op2(intType, op, x, y, state_before)
{}
- // accessors
- ValueStack* state_before() const { return _state_before; }
-
// generic
HASHING3(Op2, true, op(), x()->subst(), y()->subst())
- virtual void other_values_do(ValueVisitor* f);
};
@@ -1103,11 +1045,13 @@
LEAF(NullCheck, Instruction)
private:
Value _obj;
- ValueStack* _lock_stack;
public:
// creation
- NullCheck(Value obj, ValueStack* lock_stack) : Instruction(obj->type()->base()), _obj(obj), _lock_stack(lock_stack) {
+ NullCheck(Value obj, ValueStack* state_before)
+ : Instruction(obj->type()->base(), state_before)
+ , _obj(obj)
+ {
ASSERT_VALUES
set_can_trap(true);
assert(_obj->type()->is_object(), "null check must be applied to objects only");
@@ -1116,16 +1060,13 @@
// accessors
Value obj() const { return _obj; }
- ValueStack* lock_stack() const { return _lock_stack; }
// setters
- void set_lock_stack(ValueStack* l) { _lock_stack = l; }
void set_can_trap(bool can_trap) { set_flag(CanTrapFlag, can_trap); }
// generic
virtual bool can_trap() const { return check_flag(CanTrapFlag); /* null-check elimination sets to false */ }
virtual void input_values_do(ValueVisitor* f) { f->visit(&_obj); }
- virtual void other_values_do(ValueVisitor* f);
HASHING1(NullCheck, true, obj()->subst())
};
@@ -1139,7 +1080,10 @@
public:
// creation
- StateSplit(ValueType* type) : Instruction(type), _state(NULL) {
+ StateSplit(ValueType* type, ValueStack* state_before = NULL)
+ : Instruction(type, state_before)
+ , _state(NULL)
+ {
pin(PinStateSplitConstructor);
}
@@ -1148,7 +1092,7 @@
IRScope* scope() const; // the state's scope
// manipulation
- void set_state(ValueStack* state) { _state = state; }
+ void set_state(ValueStack* state) { assert(_state == NULL, "overwriting existing state"); check_state(state); _state = state; }
// generic
virtual void input_values_do(ValueVisitor* f) { /* no values */ }
@@ -1164,7 +1108,6 @@
BasicTypeList* _signature;
int _vtable_index;
ciMethod* _target;
- ValueStack* _state_before; // Required for deoptimization.
public:
// creation
@@ -1180,7 +1123,6 @@
int vtable_index() const { return _vtable_index; }
BasicTypeList* signature() const { return _signature; }
ciMethod* target() const { return _target; }
- ValueStack* state_before() const { return _state_before; }
// Returns false if target is not loaded
bool target_is_final() const { return check_flag(TargetIsFinalFlag); }
@@ -1191,6 +1133,8 @@
// JSR 292 support
bool is_invokedynamic() const { return code() == Bytecodes::_invokedynamic; }
+ virtual bool needs_exception_state() const { return false; }
+
// generic
virtual bool can_trap() const { return true; }
virtual void input_values_do(ValueVisitor* f) {
@@ -1208,11 +1152,16 @@
public:
// creation
- NewInstance(ciInstanceKlass* klass) : StateSplit(instanceType), _klass(klass) {}
+ NewInstance(ciInstanceKlass* klass, ValueStack* state_before)
+ : StateSplit(instanceType, state_before)
+ , _klass(klass)
+ {}
// accessors
ciInstanceKlass* klass() const { return _klass; }
+ virtual bool needs_exception_state() const { return false; }
+
// generic
virtual bool can_trap() const { return true; }
ciType* exact_type() const;
@@ -1222,22 +1171,24 @@
BASE(NewArray, StateSplit)
private:
Value _length;
- ValueStack* _state_before;
public:
// creation
- NewArray(Value length, ValueStack* state_before) : StateSplit(objectType), _length(length), _state_before(state_before) {
+ NewArray(Value length, ValueStack* state_before)
+ : StateSplit(objectType, state_before)
+ , _length(length)
+ {
// Do not ASSERT_VALUES since length is NULL for NewMultiArray
}
// accessors
- ValueStack* state_before() const { return _state_before; }
Value length() const { return _length; }
+ virtual bool needs_exception_state() const { return false; }
+
// generic
virtual bool can_trap() const { return true; }
virtual void input_values_do(ValueVisitor* f) { StateSplit::input_values_do(f); f->visit(&_length); }
- virtual void other_values_do(ValueVisitor* f);
};
@@ -1247,7 +1198,10 @@
public:
// creation
- NewTypeArray(Value length, BasicType elt_type) : NewArray(length, NULL), _elt_type(elt_type) {}
+ NewTypeArray(Value length, BasicType elt_type, ValueStack* state_before)
+ : NewArray(length, state_before)
+ , _elt_type(elt_type)
+ {}
// accessors
BasicType elt_type() const { return _elt_type; }
@@ -1303,7 +1257,6 @@
private:
ciKlass* _klass;
Value _obj;
- ValueStack* _state_before;
ciMethod* _profiled_method;
int _profiled_bci;
@@ -1311,14 +1264,13 @@
public:
// creation
TypeCheck(ciKlass* klass, Value obj, ValueType* type, ValueStack* state_before)
- : StateSplit(type), _klass(klass), _obj(obj), _state_before(state_before),
+ : StateSplit(type, state_before), _klass(klass), _obj(obj),
_profiled_method(NULL), _profiled_bci(0) {
ASSERT_VALUES
set_direct_compare(false);
}
// accessors
- ValueStack* state_before() const { return _state_before; }
ciKlass* klass() const { return _klass; }
Value obj() const { return _obj; }
bool is_loaded() const { return klass() != NULL; }
@@ -1330,7 +1282,6 @@
// generic
virtual bool can_trap() const { return true; }
virtual void input_values_do(ValueVisitor* f) { StateSplit::input_values_do(f); f->visit(&_obj); }
- virtual void other_values_do(ValueVisitor* f);
// Helpers for methodDataOop profiling
void set_should_profile(bool value) { set_flag(ProfileMDOFlag, value); }
@@ -1364,6 +1315,8 @@
public:
// creation
InstanceOf(ciKlass* klass, Value obj, ValueStack* state_before) : TypeCheck(klass, obj, intType, state_before) {}
+
+ virtual bool needs_exception_state() const { return false; }
};
@@ -1374,8 +1327,8 @@
public:
// creation
- AccessMonitor(Value obj, int monitor_no)
- : StateSplit(illegalType)
+ AccessMonitor(Value obj, int monitor_no, ValueStack* state_before = NULL)
+ : StateSplit(illegalType, state_before)
, _obj(obj)
, _monitor_no(monitor_no)
{
@@ -1393,22 +1346,14 @@
LEAF(MonitorEnter, AccessMonitor)
- private:
- ValueStack* _lock_stack_before;
-
public:
// creation
- MonitorEnter(Value obj, int monitor_no, ValueStack* lock_stack_before)
- : AccessMonitor(obj, monitor_no)
- , _lock_stack_before(lock_stack_before)
+ MonitorEnter(Value obj, int monitor_no, ValueStack* state_before)
+ : AccessMonitor(obj, monitor_no, state_before)
{
ASSERT_VALUES
}
- // accessors
- ValueStack* lock_stack_before() const { return _lock_stack_before; }
- virtual void state_values_do(ValueVisitor* f);
-
// generic
virtual bool can_trap() const { return true; }
};
@@ -1417,7 +1362,11 @@
LEAF(MonitorExit, AccessMonitor)
public:
// creation
- MonitorExit(Value obj, int monitor_no) : AccessMonitor(obj, monitor_no) {}
+ MonitorExit(Value obj, int monitor_no)
+ : AccessMonitor(obj, monitor_no, NULL)
+ {
+ ASSERT_VALUES
+ }
};
@@ -1425,7 +1374,6 @@
private:
vmIntrinsics::ID _id;
Values* _args;
- ValueStack* _lock_stack;
Value _recv;
public:
@@ -1440,13 +1388,12 @@
vmIntrinsics::ID id,
Values* args,
bool has_receiver,
- ValueStack* lock_stack,
+ ValueStack* state_before,
bool preserves_state,
bool cantrap = true)
- : StateSplit(type)
+ : StateSplit(type, state_before)
, _id(id)
, _args(args)
- , _lock_stack(lock_stack)
, _recv(NULL)
{
assert(args != NULL, "args must exist");
@@ -1468,7 +1415,6 @@
vmIntrinsics::ID id() const { return _id; }
int number_of_arguments() const { return _args->length(); }
Value argument_at(int i) const { return _args->at(i); }
- ValueStack* lock_stack() const { return _lock_stack; }
bool has_receiver() const { return (_recv != NULL); }
Value receiver() const { assert(has_receiver(), "must have receiver"); return _recv; }
@@ -1480,8 +1426,6 @@
StateSplit::input_values_do(f);
for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
}
- virtual void state_values_do(ValueVisitor* f);
-
};
@@ -1490,6 +1434,7 @@
LEAF(BlockBegin, StateSplit)
private:
int _block_id; // the unique block id
+ int _bci; // start-bci of block
int _depth_first_number; // number of this block in a depth-first ordering
int _linear_scan_number; // number of this block in linear-scan ordering
int _loop_depth; // the loop nesting level of this block
@@ -1546,6 +1491,7 @@
// creation
BlockBegin(int bci)
: StateSplit(illegalType)
+ , _bci(bci)
, _depth_first_number(-1)
, _linear_scan_number(-1)
, _loop_depth(0)
@@ -1570,11 +1516,14 @@
, _total_preds(0)
, _stores_to_locals()
{
- set_bci(bci);
+#ifndef PRODUCT
+ set_printable_bci(bci);
+#endif
}
// accessors
int block_id() const { return _block_id; }
+ int bci() const { return _bci; }
BlockList* successors() { return &_successors; }
BlockBegin* dominator() const { return _dominator; }
int loop_depth() const { return _loop_depth; }
@@ -1596,7 +1545,6 @@
BitMap& stores_to_locals() { return _stores_to_locals; }
// manipulation
- void set_bci(int bci) { Instruction::set_bci(bci); }
void set_dominator(BlockBegin* dom) { _dominator = dom; }
void set_loop_depth(int d) { _loop_depth = d; }
void set_depth_first_number(int dfn) { _depth_first_number = dfn; }
@@ -1694,7 +1642,6 @@
private:
BlockBegin* _begin;
BlockList* _sux;
- ValueStack* _state_before;
protected:
BlockList* sux() const { return _sux; }
@@ -1710,24 +1657,20 @@
public:
// creation
BlockEnd(ValueType* type, ValueStack* state_before, bool is_safepoint)
- : StateSplit(type)
+ : StateSplit(type, state_before)
, _begin(NULL)
, _sux(NULL)
- , _state_before(state_before) {
+ {
set_flag(IsSafepointFlag, is_safepoint);
}
// accessors
- ValueStack* state_before() const { return _state_before; }
bool is_safepoint() const { return check_flag(IsSafepointFlag); }
BlockBegin* begin() const { return _begin; }
// manipulation
void set_begin(BlockBegin* begin);
- // generic
- virtual void other_values_do(ValueVisitor* f);
-
// successors
int number_of_sux() const { return _sux != NULL ? _sux->length() : 0; }
BlockBegin* sux_at(int i) const { return _sux->at(i); }
@@ -1919,6 +1862,8 @@
Value tag() const { return _tag; }
int length() const { return number_of_sux() - 1; }
+ virtual bool needs_exception_state() const { return false; }
+
// generic
virtual void input_values_do(ValueVisitor* f) { BlockEnd::input_values_do(f); f->visit(&_tag); }
};
@@ -1996,7 +1941,6 @@
// generic
virtual bool can_trap() const { return true; }
virtual void input_values_do(ValueVisitor* f) { BlockEnd::input_values_do(f); f->visit(&_exception); }
- virtual void state_values_do(ValueVisitor* f);
};
@@ -2091,7 +2035,6 @@
// generic
virtual void input_values_do(ValueVisitor* f) { }
- virtual void other_values_do(ValueVisitor* f) { }
};