jdk8-mips64-public/hotspot: comparison src/share/vm/c1/c1

--1:000000000000
+:f90c822e73f8
+/*
+* Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+*
+* This code is free software; you can redistribute it and/or modify it
+* under the terms of the GNU General Public License version 2 only, as
+* published by the Free Software Foundation.
+*
+* This code is distributed in the hope that it will be useful, but WITHOUT
+* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+* version 2 for more details (a copy is included in the LICENSE file that
+* accompanied this code).
+*
+* You should have received a copy of the GNU General Public License version
+* 2 along with this work; if not, write to the Free Software Foundation,
+* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+*
+* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+* or visit www.oracle.com if you need additional information or have any
+* questions.
+*
+*/
+#ifndef SHARE_VM_C1_C1_INSTRUCTION_HPP
+#define SHARE_VM_C1_C1_INSTRUCTION_HPP
+#include "c1/c1_Compilation.hpp"
+#include "c1/c1_LIR.hpp"
+#include "c1/c1_ValueType.hpp"
+#include "ci/ciField.hpp"
+// Predefined classes
+class ciField;
+class ValueStack;
+class InstructionPrinter;
+class IRScope;
+class LIR_OprDesc;
+typedef LIR_OprDesc* LIR_Opr;
+// Instruction class hierarchy
+//
+// All leaf classes in the class hierarchy are concrete classes
+// (i.e., are instantiated). All other classes are abstract and
+// serve factoring.
+class Instruction;
+class   Phi;
+class   Local;
+class   Constant;
+class   AccessField;
+class     LoadField;
+class     StoreField;
+class   AccessArray;
+class     ArrayLength;
+class     AccessIndexed;
+class       LoadIndexed;
+class       StoreIndexed;
+class   NegateOp;
+class   Op2;
+class     ArithmeticOp;
+class     ShiftOp;
+class     LogicOp;
+class     CompareOp;
+class     IfOp;
+class   Convert;
+class   NullCheck;
+class   TypeCast;
+class   OsrEntry;
+class   ExceptionObject;
+class   StateSplit;
+class     Invoke;
+class     NewInstance;
+class     NewArray;
+class       NewTypeArray;
+class       NewObjectArray;
+class       NewMultiArray;
+class     TypeCheck;
+class       CheckCast;
+class       InstanceOf;
+class     AccessMonitor;
+class       MonitorEnter;
+class       MonitorExit;
+class     Intrinsic;
+class     BlockBegin;
+class     BlockEnd;
+class       Goto;
+class       If;
+class       IfInstanceOf;
+class       Switch;
+class         TableSwitch;
+class         LookupSwitch;
+class       Return;
+class       Throw;
+class       Base;
+class   RoundFP;
+class   UnsafeOp;
+class     UnsafeRawOp;
+class       UnsafeGetRaw;
+class       UnsafePutRaw;
+class     UnsafeObjectOp;
+class       UnsafeGetObject;
+class       UnsafePutObject;
+class         UnsafeGetAndSetObject;
+class       UnsafePrefetch;
+class         UnsafePrefetchRead;
+class         UnsafePrefetchWrite;
+class   ProfileCall;
+class   ProfileReturnType;
+class   ProfileInvoke;
+class   RuntimeCall;
+class   MemBar;
+class   RangeCheckPredicate;
+#ifdef ASSERT
+class   Assert;
+#endif
+// A Value is a reference to the instruction creating the value
+typedef Instruction* Value;
+define_array(ValueArray, Value)
+define_stack(Values, ValueArray)
+define_array(ValueStackArray, ValueStack*)
+define_stack(ValueStackStack, ValueStackArray)
+// BlockClosure is the base class for block traversal/iteration.
+class BlockClosure: public CompilationResourceObj {
+public:
+virtual void block_do(BlockBegin* block)       = 0;
+};
+// A simple closure class for visiting the values of an Instruction
+class ValueVisitor: public StackObj {
+public:
+virtual void visit(Value* v) = 0;
+};
+// Some array and list classes
+define_array(BlockBeginArray, BlockBegin*)
+define_stack(_BlockList, BlockBeginArray)
+class BlockList: public _BlockList {
+public:
+BlockList(): _BlockList() {}
+BlockList(const int size): _BlockList(size) {}
+BlockList(const int size, BlockBegin* init): _BlockList(size, init) {}
+void iterate_forward(BlockClosure* closure);
+void iterate_backward(BlockClosure* closure);
+void blocks_do(void f(BlockBegin*));
+void values_do(ValueVisitor* f);
+void print(bool cfg_only = false, bool live_only = false) PRODUCT_RETURN;
+};
+// InstructionVisitors provide type-based dispatch for instructions.
+// For each concrete Instruction class X, a virtual function do_X is
+// provided. Functionality that needs to be implemented for all classes
+// (e.g., printing, code generation) is factored out into a specialised
+// visitor instead of added to the Instruction classes itself.
+class InstructionVisitor: public StackObj {
+public:
+virtual void do_Phi            (Phi*             x) = 0;
+virtual void do_Local          (Local*           x) = 0;
+virtual void do_Constant       (Constant*        x) = 0;
+virtual void do_LoadField      (LoadField*       x) = 0;
+virtual void do_StoreField     (StoreField*      x) = 0;
+virtual void do_ArrayLength    (ArrayLength*     x) = 0;
+virtual void do_LoadIndexed    (LoadIndexed*     x) = 0;
+virtual void do_StoreIndexed   (StoreIndexed*    x) = 0;
+virtual void do_NegateOp       (NegateOp*        x) = 0;
+virtual void do_ArithmeticOp   (ArithmeticOp*    x) = 0;
+virtual void do_ShiftOp        (ShiftOp*         x) = 0;
+virtual void do_LogicOp        (LogicOp*         x) = 0;
+virtual void do_CompareOp      (CompareOp*       x) = 0;
+virtual void do_IfOp           (IfOp*            x) = 0;
+virtual void do_Convert        (Convert*         x) = 0;
+virtual void do_NullCheck      (NullCheck*       x) = 0;
+virtual void do_TypeCast       (TypeCast*        x) = 0;
+virtual void do_Invoke         (Invoke*          x) = 0;
+virtual void do_NewInstance    (NewInstance*     x) = 0;
+virtual void do_NewTypeArray   (NewTypeArray*    x) = 0;
+virtual void do_NewObjectArray (NewObjectArray*  x) = 0;
+virtual void do_NewMultiArray  (NewMultiArray*   x) = 0;
+virtual void do_CheckCast      (CheckCast*       x) = 0;
+virtual void do_InstanceOf     (InstanceOf*      x) = 0;
+virtual void do_MonitorEnter   (MonitorEnter*    x) = 0;
+virtual void do_MonitorExit    (MonitorExit*     x) = 0;
+virtual void do_Intrinsic      (Intrinsic*       x) = 0;
+virtual void do_BlockBegin     (BlockBegin*      x) = 0;
+virtual void do_Goto           (Goto*            x) = 0;
+virtual void do_If             (If*              x) = 0;
+virtual void do_IfInstanceOf   (IfInstanceOf*    x) = 0;
+virtual void do_TableSwitch    (TableSwitch*     x) = 0;
+virtual void do_LookupSwitch   (LookupSwitch*    x) = 0;
+virtual void do_Return         (Return*          x) = 0;
+virtual void do_Throw          (Throw*           x) = 0;
+virtual void do_Base           (Base*            x) = 0;
+virtual void do_OsrEntry       (OsrEntry*        x) = 0;
+virtual void do_ExceptionObject(ExceptionObject* x) = 0;
+virtual void do_RoundFP        (RoundFP*         x) = 0;
+virtual void do_UnsafeGetRaw   (UnsafeGetRaw*    x) = 0;
+virtual void do_UnsafePutRaw   (UnsafePutRaw*    x) = 0;
+virtual void do_UnsafeGetObject(UnsafeGetObject* x) = 0;
+virtual void do_UnsafePutObject(UnsafePutObject* x) = 0;
+virtual void do_UnsafeGetAndSetObject(UnsafeGetAndSetObject* x) = 0;
+virtual void do_UnsafePrefetchRead (UnsafePrefetchRead*  x) = 0;
+virtual void do_UnsafePrefetchWrite(UnsafePrefetchWrite* x) = 0;
+virtual void do_ProfileCall    (ProfileCall*     x) = 0;
+virtual void do_ProfileReturnType (ProfileReturnType*  x) = 0;
+virtual void do_ProfileInvoke  (ProfileInvoke*   x) = 0;
+virtual void do_RuntimeCall    (RuntimeCall*     x) = 0;
+virtual void do_MemBar         (MemBar*          x) = 0;
+virtual void do_RangeCheckPredicate(RangeCheckPredicate* x) = 0;
+#ifdef ASSERT
+virtual void do_Assert         (Assert*          x) = 0;
+#endif
+};
+// Hashing support
+//
+// Note: This hash functions affect the performance
+//       of ValueMap - make changes carefully!
+#define HASH1(x1            )                    ((intx)(x1))
+#define HASH2(x1, x2        )                    ((HASH1(x1        ) << 7) ^ HASH1(x2))
+#define HASH3(x1, x2, x3    )                    ((HASH2(x1, x2    ) << 7) ^ HASH1(x3))
+#define HASH4(x1, x2, x3, x4)                    ((HASH3(x1, x2, x3) << 7) ^ HASH1(x4))
+// The following macros are used to implement instruction-specific hashing.
+// By default, each instruction implements hash() and is_equal(Value), used
+// for value numbering/common subexpression elimination. The default imple-
+// mentation disables value numbering. Each instruction which can be value-
+// numbered, should define corresponding hash() and is_equal(Value) functions
+// via the macros below. The f arguments specify all the values/op codes, etc.
+// that need to be identical for two instructions to be identical.
+//
+// Note: The default implementation of hash() returns 0 in order to indicate
+//       that the instruction should not be considered for value numbering.
+//       The currently used hash functions do not guarantee that never a 0
+//       is produced. While this is still correct, it may be a performance
+//       bug (no value numbering for that node). However, this situation is
+//       so unlikely, that we are not going to handle it specially.
+#define HASHING1(class_name, enabled, f1)             \
+virtual intx hash() const {                         \
+return (enabled) ? HASH2(name(), f1) : 0;         \
+}                                                   \
+virtual bool is_equal(Value v) const {              \
+if (!(enabled)  ) return false;                   \
+class_name* _v = v->as_##class_name();            \
+if (_v == NULL  ) return false;                   \
+if (f1 != _v->f1) return false;                   \
+return true;                                      \
+}                                                   \
+#define HASHING2(class_name, enabled, f1, f2)         \
+virtual intx hash() const {                         \
+return (enabled) ? HASH3(name(), f1, f2) : 0;     \
+}                                                   \
+virtual bool is_equal(Value v) const {              \
+if (!(enabled)  ) return false;                   \
+class_name* _v = v->as_##class_name();            \
+if (_v == NULL  ) return false;                   \
+if (f1 != _v->f1) return false;                   \
+if (f2 != _v->f2) return false;                   \
+return true;                                      \
+}                                                   \
+#define HASHING3(class_name, enabled, f1, f2, f3)     \
+virtual intx hash() const {                          \
+return (enabled) ? HASH4(name(), f1, f2, f3) : 0; \
+}                                                   \
+virtual bool is_equal(Value v) const {              \
+if (!(enabled)  ) return false;                   \
+class_name* _v = v->as_##class_name();            \
+if (_v == NULL  ) return false;                   \
+if (f1 != _v->f1) return false;                   \
+if (f2 != _v->f2) return false;                   \
+if (f3 != _v->f3) return false;                   \
+return true;                                      \
+}                                                   \
+// The mother of all instructions...
+class Instruction: public CompilationResourceObj {
+private:
+int          _id;                              // the unique instruction id
+#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
+Instruction* _next;                            // the next instruction if any (NULL for BlockEnd instructions)
+Instruction* _subst;                           // the substitution instruction if any
+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
+friend class UseCountComputer;
+friend class BlockBegin;
+void update_exception_state(ValueStack* state);
+protected:
+BlockBegin*  _block;                           // Block that contains this instruction
+void set_type(ValueType* type) {
+assert(type != NULL, "type must exist");
+_type = type;
+}
+// Helper class to keep track of which arguments need a null check
+class ArgsNonNullState {
+private:
+int _nonnull_state; // mask identifying which args are nonnull
+public:
+ArgsNonNullState()
+: _nonnull_state(AllBits) {}
+// Does argument number i needs a null check?
+bool arg_needs_null_check(int i) const {
+// No data is kept for arguments starting at position 33 so
+// conservatively assume that they need a null check.
+if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
+return is_set_nth_bit(_nonnull_state, i);
+}
+return true;
+}
+// Set whether argument number i needs a null check or not
+void set_arg_needs_null_check(int i, bool check) {
+if (i >= 0 && i < (int)sizeof(_nonnull_state) * BitsPerByte) {
+if (check) {
+_nonnull_state |= nth_bit(i);
+} else {
+_nonnull_state &= ~(nth_bit(i));
+}
+}
+}
+};
+public:
+void* operator new(size_t size) throw() {
+Compilation* c = Compilation::current();
+void* res = c->arena()->Amalloc(size);
+((Instruction*)res)->_id = c->get_next_id();
+return res;
+}
+static const int no_bci = -99;
+enum InstructionFlag {
+NeedsNullCheckFlag = 0,
+CanTrapFlag,
+DirectCompareFlag,
+IsEliminatedFlag,
+IsSafepointFlag,
+IsStaticFlag,
+IsStrictfpFlag,
+NeedsStoreCheckFlag,
+NeedsWriteBarrierFlag,
+PreservesStateFlag,
+TargetIsFinalFlag,
+TargetIsLoadedFlag,
+TargetIsStrictfpFlag,
+UnorderedIsTrueFlag,
+NeedsPatchingFlag,
+ThrowIncompatibleClassChangeErrorFlag,
+ProfileMDOFlag,
+IsLinkedInBlockFlag,
+NeedsRangeCheckFlag,
+InWorkListFlag,
+DeoptimizeOnException,
+InstructionLastFlag
+};
+public:
+bool check_flag(InstructionFlag id) const      { return (_flags & (1 << id)) != 0;    }
+void set_flag(InstructionFlag id, bool f)      { _flags = f ? (_flags | (1 << id)) : (_flags & ~(1 << id)); };
+// 'globally' used condition values
+enum Condition {
+eql, neq, lss, leq, gtr, geq, aeq, beq
+};
+// Instructions may be pinned for many reasons and under certain conditions
+// with enough knowledge it's possible to safely unpin them.
+enum PinReason {
+PinUnknown           = 1 << 0
+, PinExplicitNullCheck = 1 << 3
+, PinStackForStateSplit= 1 << 12
+, PinStateSplitConstructor= 1 << 13
+, PinGlobalValueNumbering= 1 << 14
+};
+static Condition mirror(Condition cond);
+static Condition negate(Condition cond);
+// initialization
+static int number_of_instructions() {
+return Compilation::current()->number_of_instructions();
+}
+// creation
+Instruction(ValueType* type, ValueStack* state_before = NULL, bool type_is_constant = false)
+: _use_count(0)
+#ifndef PRODUCT
+, _printable_bci(-99)
+#endif
+, _pin_state(0)
+, _type(type)
+, _next(NULL)
+, _block(NULL)
+, _subst(NULL)
+, _flags(0)
+, _operand(LIR_OprFact::illegalOpr)
+, _state_before(state_before)
+, _exception_handlers(NULL)
+{
+check_state(state_before);
+assert(type != NULL && (!type->is_constant() || type_is_constant), "type must exist");
+update_exception_state(_state_before);
+}
+// accessors
+int id() const                                 { return _id; }
+#ifndef PRODUCT
+bool has_printable_bci() const                 { return _printable_bci != -99; }
+int printable_bci() const                      { assert(has_printable_bci(), "_printable_bci should have been set"); return _printable_bci; }
+void set_printable_bci(int bci)                { _printable_bci = bci; }
+#endif
+int dominator_depth();
+int use_count() const                          { return _use_count; }
+int pin_state() const                          { return _pin_state; }
+bool is_pinned() const                         { return _pin_state != 0 || PinAllInstructions; }
+ValueType* type() const                        { return _type; }
+BlockBegin *block() const                      { return _block; }
+Instruction* prev();                           // use carefully, expensive operation
+Instruction* next() const                      { return _next; }
+bool has_subst() const                         { return _subst != NULL; }
+Instruction* subst()                           { return _subst == NULL ? this : _subst->subst(); }
+LIR_Opr operand() const                        { return _operand; }
+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; }
+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
+void pin(PinReason reason)                     { _pin_state |= reason; }
+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; }
+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");
+BlockBegin *block = this->block();
+next->_block = block;
+next->set_flag(Instruction::IsLinkedInBlockFlag, true);
+_next = next;
+return next;
+}
+Instruction* set_next(Instruction* next, int bci) {
+#ifndef PRODUCT
+next->set_printable_bci(bci);
+#endif
+return set_next(next);
+}
+// when blocks are merged
+void fixup_block_pointers() {
+Instruction *cur = next()->next(); // next()'s block is set in set_next
+while (cur && cur->_block != block()) {
+cur->_block = block();
+cur = cur->next();
+}
+}
+Instruction *insert_after(Instruction *i) {
+Instruction* n = _next;
+set_next(i);
+i->set_next(n);
+return _next;
+}
+Instruction *insert_after_same_bci(Instruction *i) {
+#ifndef PRODUCT
+i->set_printable_bci(printable_bci());
+#endif
+return insert_after(i);
+}
+void set_subst(Instruction* subst)             {
+assert(subst == NULL ||
+type()->base() == subst->type()->base() ||
+subst->type()->base() == illegalType, "type can't change");
+_subst = subst;
+}
+void set_exception_handlers(XHandlers *xhandlers) { _exception_handlers = xhandlers; }
+void set_exception_state(ValueStack* s)        { check_state(s); _exception_state = s; }
+void set_state_before(ValueStack* s)           { check_state(s); _state_before = s; }
+// machine-specifics
+void set_operand(LIR_Opr operand)              { assert(operand != LIR_OprFact::illegalOpr, "operand must exist"); _operand = operand; }
+void clear_operand()                           { _operand = LIR_OprFact::illegalOpr; }
+// generic
+virtual Instruction*      as_Instruction()     { return this; } // to satisfy HASHING1 macro
+virtual Phi*              as_Phi()             { return NULL; }
+virtual Local*            as_Local()           { return NULL; }
+virtual Constant*         as_Constant()        { return NULL; }
+virtual AccessField*      as_AccessField()     { return NULL; }
+virtual LoadField*        as_LoadField()       { return NULL; }
+virtual StoreField*       as_StoreField()      { return NULL; }
+virtual AccessArray*      as_AccessArray()     { return NULL; }
+virtual ArrayLength*      as_ArrayLength()     { return NULL; }
+virtual AccessIndexed*    as_AccessIndexed()   { return NULL; }
+virtual LoadIndexed*      as_LoadIndexed()     { return NULL; }
+virtual StoreIndexed*     as_StoreIndexed()    { return NULL; }
+virtual NegateOp*         as_NegateOp()        { return NULL; }
+virtual Op2*              as_Op2()             { return NULL; }
+virtual ArithmeticOp*     as_ArithmeticOp()    { return NULL; }
+virtual ShiftOp*          as_ShiftOp()         { return NULL; }
+virtual LogicOp*          as_LogicOp()         { return NULL; }
+virtual CompareOp*        as_CompareOp()       { return NULL; }
+virtual IfOp*             as_IfOp()            { return NULL; }
+virtual Convert*          as_Convert()         { return NULL; }
+virtual NullCheck*        as_NullCheck()       { return NULL; }
+virtual OsrEntry*         as_OsrEntry()        { return NULL; }
+virtual StateSplit*       as_StateSplit()      { return NULL; }
+virtual Invoke*           as_Invoke()          { return NULL; }
+virtual NewInstance*      as_NewInstance()     { return NULL; }
+virtual NewArray*         as_NewArray()        { return NULL; }
+virtual NewTypeArray*     as_NewTypeArray()    { return NULL; }
+virtual NewObjectArray*   as_NewObjectArray()  { return NULL; }
+virtual NewMultiArray*    as_NewMultiArray()   { return NULL; }
+virtual TypeCheck*        as_TypeCheck()       { return NULL; }
+virtual CheckCast*        as_CheckCast()       { return NULL; }
+virtual InstanceOf*       as_InstanceOf()      { return NULL; }
+virtual TypeCast*         as_TypeCast()        { return NULL; }
+virtual AccessMonitor*    as_AccessMonitor()   { return NULL; }
+virtual MonitorEnter*     as_MonitorEnter()    { return NULL; }
+virtual MonitorExit*      as_MonitorExit()     { return NULL; }
+virtual Intrinsic*        as_Intrinsic()       { return NULL; }
+virtual BlockBegin*       as_BlockBegin()      { return NULL; }
+virtual BlockEnd*         as_BlockEnd()        { return NULL; }
+virtual Goto*             as_Goto()            { return NULL; }
+virtual If*               as_If()              { return NULL; }
+virtual IfInstanceOf*     as_IfInstanceOf()    { return NULL; }
+virtual TableSwitch*      as_TableSwitch()     { return NULL; }
+virtual LookupSwitch*     as_LookupSwitch()    { return NULL; }
+virtual Return*           as_Return()          { return NULL; }
+virtual Throw*            as_Throw()           { return NULL; }
+virtual Base*             as_Base()            { return NULL; }
+virtual RoundFP*          as_RoundFP()         { return NULL; }
+virtual ExceptionObject*  as_ExceptionObject() { return NULL; }
+virtual UnsafeOp*         as_UnsafeOp()        { return NULL; }
+virtual ProfileInvoke*    as_ProfileInvoke()   { return NULL; }
+virtual RangeCheckPredicate* as_RangeCheckPredicate() { return NULL; }
+#ifdef ASSERT
+virtual Assert*           as_Assert()          { return NULL; }
+#endif
+virtual void visit(InstructionVisitor* v)      = 0;
+virtual bool can_trap() const                  { return false; }
+virtual void input_values_do(ValueVisitor* f)   = 0;
+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); }
+virtual ciType* exact_type() const;
+virtual ciType* declared_type() const          { return NULL; }
+// hashing
+virtual const char* name() const               = 0;
+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;
+};
+// The following macros are used to define base (i.e., non-leaf)
+// and leaf instruction classes. They define class-name related
+// generic functionality in one place.
+#define BASE(class_name, super_class_name)       \
+class class_name: public super_class_name {    \
+public:                                       \
+virtual class_name* as_##class_name()        { return this; }              \
+#define LEAF(class_name, super_class_name)       \
+BASE(class_name, super_class_name)             \
+public:                                       \
+virtual const char* name() const             { return #class_name; }       \
+virtual void visit(InstructionVisitor* v)    { v->do_##class_name(this); } \
+// Debugging support
+#ifdef ASSERT
+class AssertValues: public ValueVisitor {
+void visit(Value* x)             { assert((*x) != NULL, "value must exist"); }
+};
+#define ASSERT_VALUES                          { AssertValues assert_value; values_do(&assert_value); }
+#else
+#define ASSERT_VALUES
+#endif // ASSERT
+// 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.
+LEAF(Phi, Instruction)
+private:
+int         _pf_flags; // the flags of the phi function
+int         _index;    // to value on operand stack (index < 0) or to local
+public:
+// creation
+Phi(ValueType* type, BlockBegin* b, int index)
+: Instruction(type->base())
+, _pf_flags(0)
+, _index(index)
+{
+_block = b;
+NOT_PRODUCT(set_printable_bci(Value(b)->printable_bci()));
+if (type->is_illegal()) {
+make_illegal();
+}
+}
+// flags
+enum Flag {
+no_flag         = 0,
+visited         = 1 << 0,
+cannot_simplify = 1 << 1
+};
+// accessors
+bool  is_local() const          { return _index >= 0; }
+bool  is_on_stack() const       { return !is_local(); }
+int   local_index() const       { assert(is_local(), ""); return _index; }
+int   stack_index() const       { assert(is_on_stack(), ""); return -(_index+1); }
+Value operand_at(int i) const;
+int   operand_count() const;
+void   set(Flag f)              { _pf_flags |=  f; }
+void   clear(Flag f)            { _pf_flags &= ~f; }
+bool   is_set(Flag f) const     { return (_pf_flags & f) != 0; }
+// Invalidates phis corresponding to merges of locals of two different types
+// (these should never be referenced, otherwise the bytecodes are illegal)
+void   make_illegal() {
+set(cannot_simplify);
+set_type(illegalType);
+}
+bool is_illegal() const {
+return type()->is_illegal();
+}
+// generic
+virtual void input_values_do(ValueVisitor* f) {
+}
+};
+// A local is a placeholder for an incoming argument to a function call.
+LEAF(Local, Instruction)
+private:
+int      _java_index;                          // the local index within the method to which the local belongs
+ciType*  _declared_type;
+public:
+// creation
+Local(ciType* declared, ValueType* type, int index)
+: Instruction(type)
+, _java_index(index)
+, _declared_type(declared)
+{
+NOT_PRODUCT(set_printable_bci(-1));
+}
+// accessors
+int java_index() const                         { return _java_index; }
+virtual ciType* declared_type() const          { return _declared_type; }
+// generic
+virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
+};
+LEAF(Constant, Instruction)
+public:
+// creation
+Constant(ValueType* type):
+Instruction(type, NULL, /*type_is_constant*/ true)
+{
+assert(type->is_constant(), "must be a constant");
+}
+Constant(ValueType* type, ValueStack* state_before):
+Instruction(type, state_before, /*type_is_constant*/ 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();
+}
+// generic
+virtual bool can_trap() const                  { return state_before() != NULL; }
+virtual void input_values_do(ValueVisitor* f)   { /* no values */ }
+virtual intx hash() const;
+virtual bool is_equal(Value v) const;
+virtual ciType* exact_type() const;
+enum CompareResult { not_comparable = -1, cond_false, cond_true };
+virtual CompareResult compare(Instruction::Condition condition, Value right) const;
+BlockBegin* compare(Instruction::Condition cond, Value right,
+BlockBegin* true_sux, BlockBegin* false_sux) const {
+switch (compare(cond, right)) {
+case not_comparable:
+return NULL;
+case cond_false:
+return false_sux;
+case cond_true:
+return true_sux;
+default:
+ShouldNotReachHere();
+return NULL;
+}
+}
+};
+BASE(AccessField, Instruction)
+private:
+Value       _obj;
+int         _offset;
+ciField*    _field;
+NullCheck*  _explicit_null_check;              // For explicit null check elimination
+public:
+// creation
+AccessField(Value obj, int offset, ciField* field, bool is_static,
+ValueStack* state_before, bool needs_patching)
+: Instruction(as_ValueType(field->type()->basic_type()), state_before)
+, _obj(obj)
+, _offset(offset)
+, _field(field)
+, _explicit_null_check(NULL)
+{
+set_needs_null_check(!is_static);
+set_flag(IsStaticFlag, is_static);
+set_flag(NeedsPatchingFlag, needs_patching);
+ASSERT_VALUES
+// pin of all instructions with memory access
+pin();
+}
+// accessors
+Value obj() const                              { return _obj; }
+int offset() const                             { return _offset; }
+ciField* field() const                         { return _field; }
+BasicType field_type() const                   { return _field->type()->basic_type(); }
+bool is_static() const                         { return check_flag(IsStaticFlag); }
+NullCheck* explicit_null_check() const         { return _explicit_null_check; }
+bool needs_patching() const                    { return check_flag(NeedsPatchingFlag); }
+// Unresolved getstatic and putstatic can cause initialization.
+// Technically it occurs at the Constant that materializes the base
+// of the static fields but it's simpler to model it here.
+bool is_init_point() const                     { return is_static() && (needs_patching() || !_field->holder()->is_initialized()); }
+// manipulation
+// 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
+// information from the NullCheck. This field should only be consulted
+// if needs_null_check() is true.
+void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
+// generic
+virtual bool can_trap() const                  { return needs_null_check() || needs_patching(); }
+virtual void input_values_do(ValueVisitor* f)   { f->visit(&_obj); }
+};
+LEAF(LoadField, AccessField)
+public:
+// creation
+LoadField(Value obj, int offset, ciField* field, bool is_static,
+ValueStack* state_before, bool needs_patching)
+: AccessField(obj, offset, field, is_static, state_before, needs_patching)
+{}
+ciType* declared_type() const;
+// generic
+HASHING2(LoadField, !needs_patching() && !field()->is_volatile(), obj()->subst(), offset())  // cannot be eliminated if needs patching or if volatile
+};
+LEAF(StoreField, AccessField)
+private:
+Value _value;
+public:
+// creation
+StoreField(Value obj, int offset, ciField* field, Value value, bool is_static,
+ValueStack* state_before, bool needs_patching)
+: AccessField(obj, offset, field, is_static, state_before, needs_patching)
+, _value(value)
+{
+set_flag(NeedsWriteBarrierFlag, as_ValueType(field_type())->is_object());
+ASSERT_VALUES
+pin();
+}
+// accessors
+Value value() const                            { return _value; }
+bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }
+// generic
+virtual void input_values_do(ValueVisitor* f)   { AccessField::input_values_do(f); f->visit(&_value); }
+};
+BASE(AccessArray, Instruction)
+private:
+Value       _array;
+public:
+// creation
+AccessArray(ValueType* type, Value array, ValueStack* state_before)
+: Instruction(type, state_before)
+, _array(array)
+{
+set_needs_null_check(true);
+ASSERT_VALUES
+pin(); // instruction with side effect (null exception or range check throwing)
+}
+Value array() const                            { return _array; }
+// generic
+virtual bool can_trap() const                  { return needs_null_check(); }
+virtual void input_values_do(ValueVisitor* f)   { f->visit(&_array); }
+};
+LEAF(ArrayLength, AccessArray)
+private:
+NullCheck*  _explicit_null_check;              // For explicit null check elimination
+public:
+// creation
+ArrayLength(Value array, ValueStack* state_before)
+: AccessArray(intType, array, state_before)
+, _explicit_null_check(NULL) {}
+// accessors
+NullCheck* explicit_null_check() const         { return _explicit_null_check; }
+// setters
+// See LoadField::set_explicit_null_check for documentation
+void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
+// generic
+HASHING1(ArrayLength, true, array()->subst())
+};
+BASE(AccessIndexed, AccessArray)
+private:
+Value     _index;
+Value     _length;
+BasicType _elt_type;
+public:
+// creation
+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)
+{
+set_flag(Instruction::NeedsRangeCheckFlag, true);
+ASSERT_VALUES
+}
+// accessors
+Value index() const                            { return _index; }
+Value length() const                           { return _length; }
+BasicType elt_type() const                     { return _elt_type; }
+void clear_length()                            { _length = NULL; }
+// perform elimination of range checks involving constants
+bool compute_needs_range_check();
+// generic
+virtual void input_values_do(ValueVisitor* f)   { AccessArray::input_values_do(f); f->visit(&_index); if (_length != NULL) f->visit(&_length); }
+};
+LEAF(LoadIndexed, AccessIndexed)
+private:
+NullCheck*  _explicit_null_check;              // For explicit null check elimination
+public:
+// creation
+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
+NullCheck* explicit_null_check() const         { return _explicit_null_check; }
+// setters
+// See LoadField::set_explicit_null_check for documentation
+void set_explicit_null_check(NullCheck* check) { _explicit_null_check = check; }
+ciType* exact_type() const;
+ciType* declared_type() const;
+// generic
+HASHING2(LoadIndexed, true, array()->subst(), index()->subst())
+};
+LEAF(StoreIndexed, AccessIndexed)
+private:
+Value       _value;
+ciMethod* _profiled_method;
+int       _profiled_bci;
+public:
+// creation
+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()));
+set_flag(NeedsStoreCheckFlag, (as_ValueType(elt_type)->is_object()));
+ASSERT_VALUES
+pin();
+}
+// accessors
+Value value() const                            { return _value; }
+bool needs_write_barrier() const               { return check_flag(NeedsWriteBarrierFlag); }
+bool needs_store_check() const                 { return check_flag(NeedsStoreCheckFlag); }
+// Helpers for MethodData* profiling
+void set_should_profile(bool value)                { set_flag(ProfileMDOFlag, value); }
+void set_profiled_method(ciMethod* method)         { _profiled_method = method;   }
+void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
+bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
+ciMethod* profiled_method() const                  { return _profiled_method;     }
+int       profiled_bci() const                     { return _profiled_bci;        }
+// generic
+virtual void input_values_do(ValueVisitor* f)   { AccessIndexed::input_values_do(f); f->visit(&_value); }
+};
+LEAF(NegateOp, Instruction)
+private:
+Value _x;
+public:
+// creation
+NegateOp(Value x) : Instruction(x->type()->base()), _x(x) {
+ASSERT_VALUES
+}
+// accessors
+Value x() const                                { return _x; }
+// generic
+virtual void input_values_do(ValueVisitor* f)   { f->visit(&_x); }
+};
+BASE(Op2, Instruction)
+private:
+Bytecodes::Code _op;
+Value           _x;
+Value           _y;
+public:
+// creation
+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
+}
+// accessors
+Bytecodes::Code op() const                     { return _op; }
+Value x() const                                { return _x; }
+Value y() const                                { return _y; }
+// manipulators
+void swap_operands() {
+assert(is_commutative(), "operation must be commutative");
+Value t = _x; _x = _y; _y = t;
+}
+// generic
+virtual bool is_commutative() const            { return false; }
+virtual void input_values_do(ValueVisitor* f)   { f->visit(&_x); f->visit(&_y); }
+};
+LEAF(ArithmeticOp, Op2)
+public:
+// creation
+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
+bool        is_strictfp() const                { return check_flag(IsStrictfpFlag); }
+// generic
+virtual bool is_commutative() const;
+virtual bool can_trap() const;
+HASHING3(Op2, true, op(), x()->subst(), y()->subst())
+};
+LEAF(ShiftOp, Op2)
+public:
+// creation
+ShiftOp(Bytecodes::Code op, Value x, Value s) : Op2(x->type()->base(), op, x, s) {}
+// generic
+HASHING3(Op2, true, op(), x()->subst(), y()->subst())
+};
+LEAF(LogicOp, Op2)
+public:
+// creation
+LogicOp(Bytecodes::Code op, Value x, Value y) : Op2(x->type()->meet(y->type()), op, x, y) {}
+// generic
+virtual bool is_commutative() const;
+HASHING3(Op2, true, op(), x()->subst(), y()->subst())
+};
+LEAF(CompareOp, Op2)
+public:
+// creation
+CompareOp(Bytecodes::Code op, Value x, Value y, ValueStack* state_before)
+: Op2(intType, op, x, y, state_before)
+{}
+// generic
+HASHING3(Op2, true, op(), x()->subst(), y()->subst())
+};
+LEAF(IfOp, Op2)
+private:
+Value _tval;
+Value _fval;
+public:
+// creation
+IfOp(Value x, Condition cond, Value y, Value tval, Value fval)
+: Op2(tval->type()->meet(fval->type()), (Bytecodes::Code)cond, x, y)
+, _tval(tval)
+, _fval(fval)
+{
+ASSERT_VALUES
+assert(tval->type()->tag() == fval->type()->tag(), "types must match");
+}
+// accessors
+virtual bool is_commutative() const;
+Bytecodes::Code op() const                     { ShouldNotCallThis(); return Bytecodes::_illegal; }
+Condition cond() const                         { return (Condition)Op2::op(); }
+Value tval() const                             { return _tval; }
+Value fval() const                             { return _fval; }
+// generic
+virtual void input_values_do(ValueVisitor* f)   { Op2::input_values_do(f); f->visit(&_tval); f->visit(&_fval); }
+};
+LEAF(Convert, Instruction)
+private:
+Bytecodes::Code _op;
+Value           _value;
+public:
+// creation
+Convert(Bytecodes::Code op, Value value, ValueType* to_type) : Instruction(to_type), _op(op), _value(value) {
+ASSERT_VALUES
+}
+// accessors
+Bytecodes::Code op() const                     { return _op; }
+Value value() const                            { return _value; }
+// generic
+virtual void input_values_do(ValueVisitor* f)   { f->visit(&_value); }
+HASHING2(Convert, true, op(), value()->subst())
+};
+LEAF(NullCheck, Instruction)
+private:
+Value       _obj;
+public:
+// creation
+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");
+pin(Instruction::PinExplicitNullCheck);
+}
+// accessors
+Value obj() const                              { return _obj; }
+// setters
+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); }
+HASHING1(NullCheck, true, obj()->subst())
+};
+// This node is supposed to cast the type of another node to a more precise
+// declared type.
+LEAF(TypeCast, Instruction)
+private:
+ciType* _declared_type;
+Value   _obj;
+public:
+// The type of this node is the same type as the object type (and it might be constant).
+TypeCast(ciType* type, Value obj, ValueStack* state_before)
+: Instruction(obj->type(), state_before, obj->type()->is_constant()),
+_declared_type(type),
+_obj(obj) {}
+// accessors
+ciType* declared_type() const                  { return _declared_type; }
+Value   obj() const                            { return _obj; }
+// generic
+virtual void input_values_do(ValueVisitor* f)  { f->visit(&_obj); }
+};
+BASE(StateSplit, Instruction)
+private:
+ValueStack* _state;
+protected:
+static void substitute(BlockList& list, BlockBegin* old_block, BlockBegin* new_block);
+public:
+// creation
+StateSplit(ValueType* type, ValueStack* state_before = NULL)
+: Instruction(type, state_before)
+, _state(NULL)
+{
+pin(PinStateSplitConstructor);
+}
+// accessors
+ValueStack* state() const                      { return _state; }
+IRScope* scope() const;                        // the state's scope
+// manipulation
+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 */ }
+virtual void state_values_do(ValueVisitor* f);
+};
+LEAF(Invoke, StateSplit)
+private:
+Bytecodes::Code _code;
+Value           _recv;
+Values*         _args;
+BasicTypeList*  _signature;
+int             _vtable_index;
+ciMethod*       _target;
+public:
+// creation
+Invoke(Bytecodes::Code code, ValueType* result_type, Value recv, Values* args,
+int vtable_index, ciMethod* target, ValueStack* state_before);
+// accessors
+Bytecodes::Code code() const                   { return _code; }
+Value receiver() const                         { return _recv; }
+bool has_receiver() const                      { return receiver() != NULL; }
+int number_of_arguments() const                { return _args->length(); }
+Value argument_at(int i) const                 { return _args->at(i); }
+int vtable_index() const                       { return _vtable_index; }
+BasicTypeList* signature() const               { return _signature; }
+ciMethod* target() const                       { return _target; }
+ciType* declared_type() const;
+// Returns false if target is not loaded
+bool target_is_final() const                   { return check_flag(TargetIsFinalFlag); }
+bool target_is_loaded() const                  { return check_flag(TargetIsLoadedFlag); }
+// Returns false if target is not loaded
+bool target_is_strictfp() const                { return check_flag(TargetIsStrictfpFlag); }
+// JSR 292 support
+bool is_invokedynamic() const                  { return code() == Bytecodes::_invokedynamic; }
+bool is_method_handle_intrinsic() const        { return target()->is_method_handle_intrinsic(); }
+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);
+if (has_receiver()) f->visit(&_recv);
+for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
+}
+virtual void state_values_do(ValueVisitor *f);
+};
+LEAF(NewInstance, StateSplit)
+private:
+ciInstanceKlass* _klass;
+public:
+// creation
+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;
+ciType* declared_type() const;
+};
+BASE(NewArray, StateSplit)
+private:
+Value       _length;
+public:
+// creation
+NewArray(Value length, ValueStack* state_before)
+: StateSplit(objectType, state_before)
+, _length(length)
+{
+// Do not ASSERT_VALUES since length is NULL for NewMultiArray
+}
+// accessors
+Value length() const                           { return _length; }
+virtual bool needs_exception_state() const     { return false; }
+ciType* exact_type() const                     { return NULL; }
+ciType* declared_type() const;
+// generic
+virtual bool can_trap() const                  { return true; }
+virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_length); }
+};
+LEAF(NewTypeArray, NewArray)
+private:
+BasicType _elt_type;
+public:
+// creation
+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; }
+ciType* exact_type() const;
+};
+LEAF(NewObjectArray, NewArray)
+private:
+ciKlass* _klass;
+public:
+// creation
+NewObjectArray(ciKlass* klass, Value length, ValueStack* state_before) : NewArray(length, state_before), _klass(klass) {}
+// accessors
+ciKlass* klass() const                         { return _klass; }
+ciType* exact_type() const;
+};
+LEAF(NewMultiArray, NewArray)
+private:
+ciKlass* _klass;
+Values*  _dims;
+public:
+// creation
+NewMultiArray(ciKlass* klass, Values* dims, ValueStack* state_before) : NewArray(NULL, state_before), _klass(klass), _dims(dims) {
+ASSERT_VALUES
+}
+// accessors
+ciKlass* klass() const                         { return _klass; }
+Values* dims() const                           { return _dims; }
+int rank() const                               { return dims()->length(); }
+// generic
+virtual void input_values_do(ValueVisitor* f) {
+// NOTE: we do not call NewArray::input_values_do since "length"
+// is meaningless for a multi-dimensional array; passing the
+// zeroth element down to NewArray as its length is a bad idea
+// since there will be a copy in the "dims" array which doesn't
+// get updated, and the value must not be traversed twice. Was bug
+// - kbr 4/10/2001
+StateSplit::input_values_do(f);
+for (int i = 0; i < _dims->length(); i++) f->visit(_dims->adr_at(i));
+}
+};
+BASE(TypeCheck, StateSplit)
+private:
+ciKlass*    _klass;
+Value       _obj;
+ciMethod* _profiled_method;
+int       _profiled_bci;
+public:
+// creation
+TypeCheck(ciKlass* klass, Value obj, ValueType* type, ValueStack* state_before)
+: StateSplit(type, state_before), _klass(klass), _obj(obj),
+_profiled_method(NULL), _profiled_bci(0) {
+ASSERT_VALUES
+set_direct_compare(false);
+}
+// accessors
+ciKlass* klass() const                         { return _klass; }
+Value obj() const                              { return _obj; }
+bool is_loaded() const                         { return klass() != NULL; }
+bool direct_compare() const                    { return check_flag(DirectCompareFlag); }
+// manipulation
+void set_direct_compare(bool flag)             { set_flag(DirectCompareFlag, flag); }
+// generic
+virtual bool can_trap() const                  { return true; }
+virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_obj); }
+// Helpers for MethodData* profiling
+void set_should_profile(bool value)                { set_flag(ProfileMDOFlag, value); }
+void set_profiled_method(ciMethod* method)         { _profiled_method = method;   }
+void set_profiled_bci(int bci)                     { _profiled_bci = bci;         }
+bool      should_profile() const                   { return check_flag(ProfileMDOFlag); }
+ciMethod* profiled_method() const                  { return _profiled_method;     }
+int       profiled_bci() const                     { return _profiled_bci;        }
+};
+LEAF(CheckCast, TypeCheck)
+public:
+// creation
+CheckCast(ciKlass* klass, Value obj, ValueStack* state_before)
+: TypeCheck(klass, obj, objectType, state_before) {}
+void set_incompatible_class_change_check() {
+set_flag(ThrowIncompatibleClassChangeErrorFlag, true);
+}
+bool is_incompatible_class_change_check() const {
+return check_flag(ThrowIncompatibleClassChangeErrorFlag);
+}
+ciType* declared_type() const;
+};
+LEAF(InstanceOf, TypeCheck)
+public:
+// creation
+InstanceOf(ciKlass* klass, Value obj, ValueStack* state_before) : TypeCheck(klass, obj, intType, state_before) {}
+virtual bool needs_exception_state() const     { return false; }
+};
+BASE(AccessMonitor, StateSplit)
+private:
+Value       _obj;
+int         _monitor_no;
+public:
+// creation
+AccessMonitor(Value obj, int monitor_no, ValueStack* state_before = NULL)
+: StateSplit(illegalType, state_before)
+, _obj(obj)
+, _monitor_no(monitor_no)
+{
+set_needs_null_check(true);
+ASSERT_VALUES
+}
+// accessors
+Value obj() const                              { return _obj; }
+int monitor_no() const                         { return _monitor_no; }
+// generic
+virtual void input_values_do(ValueVisitor* f)   { StateSplit::input_values_do(f); f->visit(&_obj); }
+};
+LEAF(MonitorEnter, AccessMonitor)
+public:
+// creation
+MonitorEnter(Value obj, int monitor_no, ValueStack* state_before)
+: AccessMonitor(obj, monitor_no, state_before)
+{
+ASSERT_VALUES
+}
+// generic
+virtual bool can_trap() const                  { return true; }
+};
+LEAF(MonitorExit, AccessMonitor)
+public:
+// creation
+MonitorExit(Value obj, int monitor_no)
+: AccessMonitor(obj, monitor_no, NULL)
+{
+ASSERT_VALUES
+}
+};
+LEAF(Intrinsic, StateSplit)
+private:
+vmIntrinsics::ID _id;
+Values*          _args;
+Value            _recv;
+ArgsNonNullState _nonnull_state;
+public:
+// preserves_state can be set to true for Intrinsics
+// which are guaranteed to preserve register state across any slow
+// cases; setting it to true does not mean that the Intrinsic can
+// not trap, only that if we continue execution in the same basic
+// block after the Intrinsic, all of the registers are intact. This
+// allows load elimination and common expression elimination to be
+// performed across the Intrinsic.  The default value is false.
+Intrinsic(ValueType* type,
+vmIntrinsics::ID id,
+Values* args,
+bool has_receiver,
+ValueStack* state_before,
+bool preserves_state,
+bool cantrap = true)
+: StateSplit(type, state_before)
+, _id(id)
+, _args(args)
+, _recv(NULL)
+{
+assert(args != NULL, "args must exist");
+ASSERT_VALUES
+set_flag(PreservesStateFlag, preserves_state);
+set_flag(CanTrapFlag,        cantrap);
+if (has_receiver) {
+_recv = argument_at(0);
+}
+set_needs_null_check(has_receiver);
+// some intrinsics can't trap, so don't force them to be pinned
+if (!can_trap()) {
+unpin(PinStateSplitConstructor);
+}
+}
+// accessors
+vmIntrinsics::ID id() const                    { return _id; }
+int number_of_arguments() const                { return _args->length(); }
+Value argument_at(int i) const                 { return _args->at(i); }
+bool has_receiver() const                      { return (_recv != NULL); }
+Value receiver() const                         { assert(has_receiver(), "must have receiver"); return _recv; }
+bool preserves_state() const                   { return check_flag(PreservesStateFlag); }
+bool arg_needs_null_check(int i) const {
+return _nonnull_state.arg_needs_null_check(i);
+}
+void set_arg_needs_null_check(int i, bool check) {
+_nonnull_state.set_arg_needs_null_check(i, check);
+}
+// generic
+virtual bool can_trap() const                  { return check_flag(CanTrapFlag); }
+virtual void input_values_do(ValueVisitor* f) {
+StateSplit::input_values_do(f);
+for (int i = 0; i < _args->length(); i++) f->visit(_args->adr_at(i));
+}
+};
+class LIR_List;
+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        _dominator_depth;
+int        _loop_depth;                        // the loop nesting level of this block
+int        _loop_index;                        // number of the innermost loop of this block
+int        _flags;                             // the flags associated with this block
+// fields used by BlockListBuilder
+int        _total_preds;                       // number of predecessors found by BlockListBuilder
+BitMap     _stores_to_locals;                  // bit is set when a local variable is stored in the block
+// SSA specific fields: (factor out later)
+BlockList   _successors;                       // the successors of this block
+BlockList   _predecessors;                     // the predecessors of this block
+BlockList   _dominates;                        // list of blocks that are dominated by this block
+BlockBegin* _dominator;                        // the dominator of this block
+// SSA specific ends
+BlockEnd*  _end;                               // the last instruction of this block
+BlockList  _exception_handlers;                // the exception handlers potentially invoked by this block
+ValueStackStack* _exception_states;            // only for xhandler entries: states of all instructions that have an edge to this xhandler
+int        _exception_handler_pco;             // if this block is the start of an exception handler,
+// this records the PC offset in the assembly code of the
+// first instruction in this block
+Label      _label;                             // the label associated with this block
+LIR_List*  _lir;                               // the low level intermediate representation for this block
+BitMap      _live_in;                          // set of live LIR_Opr registers at entry to this block
+BitMap      _live_out;                         // set of live LIR_Opr registers at exit from this block
+BitMap      _live_gen;                         // set of registers used before any redefinition in this block
+BitMap      _live_kill;                        // set of registers defined in this block
+BitMap      _fpu_register_usage;
+intArray*   _fpu_stack_state;                  // For x86 FPU code generation with UseLinearScan
+int         _first_lir_instruction_id;         // ID of first LIR instruction in this block
+int         _last_lir_instruction_id;          // ID of last LIR instruction in this block
+void iterate_preorder (boolArray& mark, BlockClosure* closure);
+void iterate_postorder(boolArray& mark, BlockClosure* closure);
+friend class SuxAndWeightAdjuster;
+public:
+void* operator new(size_t size) throw() {
+Compilation* c = Compilation::current();
+void* res = c->arena()->Amalloc(size);
+((BlockBegin*)res)->_id = c->get_next_id();
+((BlockBegin*)res)->_block_id = c->get_next_block_id();
+return res;
+}
+// initialization/counting
+static int  number_of_blocks() {
+return Compilation::current()->number_of_blocks();
+}
+// creation
+BlockBegin(int bci)
+: StateSplit(illegalType)
+, _bci(bci)
+, _depth_first_number(-1)
+, _linear_scan_number(-1)
+, _loop_depth(0)
+, _flags(0)
+, _dominator_depth(-1)
+, _dominator(NULL)
+, _end(NULL)
+, _predecessors(2)
+, _successors(2)
+, _dominates(2)
+, _exception_handlers(1)
+, _exception_states(NULL)
+, _exception_handler_pco(-1)
+, _lir(NULL)
+, _loop_index(-1)
+, _live_in()
+, _live_out()
+, _live_gen()
+, _live_kill()
+, _fpu_register_usage()
+, _fpu_stack_state(NULL)
+, _first_lir_instruction_id(-1)
+, _last_lir_instruction_id(-1)
+, _total_preds(0)
+, _stores_to_locals()
+{
+_block = this;
+#ifndef PRODUCT
+set_printable_bci(bci);
+#endif
+}
+// accessors
+int block_id() const                           { return _block_id; }
+int bci() const                                { return _bci; }
+BlockList* successors()                        { return &_successors; }
+BlockList* dominates()                         { return &_dominates; }
+BlockBegin* dominator() const                  { return _dominator; }
+int loop_depth() const                         { return _loop_depth; }
+int dominator_depth() const                    { return _dominator_depth; }
+int depth_first_number() const                 { return _depth_first_number; }
+int linear_scan_number() const                 { return _linear_scan_number; }
+BlockEnd* end() const                          { return _end; }
+Label* label()                                 { return &_label; }
+LIR_List* lir() const                          { return _lir; }
+int exception_handler_pco() const              { return _exception_handler_pco; }
+BitMap& live_in()                              { return _live_in;        }
+BitMap& live_out()                             { return _live_out;       }
+BitMap& live_gen()                             { return _live_gen;       }
+BitMap& live_kill()                            { return _live_kill;      }
+BitMap& fpu_register_usage()                   { return _fpu_register_usage; }
+intArray* fpu_stack_state() const              { return _fpu_stack_state;    }
+int first_lir_instruction_id() const           { return _first_lir_instruction_id; }
+int last_lir_instruction_id() const            { return _last_lir_instruction_id; }
+int total_preds() const                        { return _total_preds; }
+BitMap& stores_to_locals()                     { return _stores_to_locals; }
+// manipulation
+void set_dominator(BlockBegin* dom)            { _dominator = dom; }
+void set_loop_depth(int d)                     { _loop_depth = d; }
+void set_dominator_depth(int d)                { _dominator_depth = d; }
+void set_depth_first_number(int dfn)           { _depth_first_number = dfn; }
+void set_linear_scan_number(int lsn)           { _linear_scan_number = lsn; }
+void set_end(BlockEnd* end);
+void clear_end();
+void disconnect_from_graph();
+static void disconnect_edge(BlockBegin* from, BlockBegin* to);
+BlockBegin* insert_block_between(BlockBegin* sux);
+void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
+void set_lir(LIR_List* lir)                    { _lir = lir; }
+void set_exception_handler_pco(int pco)        { _exception_handler_pco = pco; }
+void set_live_in       (BitMap map)            { _live_in = map;        }
+void set_live_out      (BitMap map)            { _live_out = map;       }
+void set_live_gen      (BitMap map)            { _live_gen = map;       }
+void set_live_kill     (BitMap map)            { _live_kill = map;      }
+void set_fpu_register_usage(BitMap map)        { _fpu_register_usage = map; }
+void set_fpu_stack_state(intArray* state)      { _fpu_stack_state = state;  }
+void set_first_lir_instruction_id(int id)      { _first_lir_instruction_id = id;  }
+void set_last_lir_instruction_id(int id)       { _last_lir_instruction_id = id;  }
+void increment_total_preds(int n = 1)          { _total_preds += n; }
+void init_stores_to_locals(int locals_count)   { _stores_to_locals = BitMap(locals_count); _stores_to_locals.clear(); }
+// generic
+virtual void state_values_do(ValueVisitor* f);
+// successors and predecessors
+int number_of_sux() const;
+BlockBegin* sux_at(int i) const;
+void add_successor(BlockBegin* sux);
+void remove_successor(BlockBegin* pred);
+bool is_successor(BlockBegin* sux) const       { return _successors.contains(sux); }
+void add_predecessor(BlockBegin* pred);
+void remove_predecessor(BlockBegin* pred);
+bool is_predecessor(BlockBegin* pred) const    { return _predecessors.contains(pred); }
+int number_of_preds() const                    { return _predecessors.length(); }
+BlockBegin* pred_at(int i) const               { return _predecessors[i]; }
+// exception handlers potentially invoked by this block
+void add_exception_handler(BlockBegin* b);
+bool is_exception_handler(BlockBegin* b) const { return _exception_handlers.contains(b); }
+int  number_of_exception_handlers() const      { return _exception_handlers.length(); }
+BlockBegin* exception_handler_at(int i) const  { return _exception_handlers.at(i); }
+// states of the instructions that have an edge to this exception handler
+int number_of_exception_states()               { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states == NULL ? 0 : _exception_states->length(); }
+ValueStack* exception_state_at(int idx) const  { assert(is_set(exception_entry_flag), "only for xhandlers"); return _exception_states->at(idx); }
+int add_exception_state(ValueStack* state);
+// flags
+enum Flag {
+no_flag                       = 0,
+std_entry_flag                = 1 << 0,
+osr_entry_flag                = 1 << 1,
+exception_entry_flag          = 1 << 2,
+subroutine_entry_flag         = 1 << 3,
+backward_branch_target_flag   = 1 << 4,
+is_on_work_list_flag          = 1 << 5,
+was_visited_flag              = 1 << 6,
+parser_loop_header_flag       = 1 << 7,  // set by parser to identify blocks where phi functions can not be created on demand
+critical_edge_split_flag      = 1 << 8, // set for all blocks that are introduced when critical edges are split
+linear_scan_loop_header_flag  = 1 << 9, // set during loop-detection for LinearScan
+linear_scan_loop_end_flag     = 1 << 10, // set during loop-detection for LinearScan
+donot_eliminate_range_checks  = 1 << 11  // Should be try to eliminate range checks in this block
+};
+void set(Flag f)                               { _flags |= f; }
+void clear(Flag f)                             { _flags &= ~f; }
+bool is_set(Flag f) const                      { return (_flags & f) != 0; }
+bool is_entry_block() const {
+const int entry_mask = std_entry_flag | osr_entry_flag | exception_entry_flag;
+return (_flags & entry_mask) != 0;
+}
+// iteration
+void iterate_preorder   (BlockClosure* closure);
+void iterate_postorder  (BlockClosure* closure);
+void block_values_do(ValueVisitor* f);
+// loops
+void set_loop_index(int ix)                    { _loop_index = ix;        }
+int  loop_index() const                        { return _loop_index;      }
+// merging
+bool try_merge(ValueStack* state);             // try to merge states at block begin
+void merge(ValueStack* state)                  { bool b = try_merge(state); assert(b, "merge failed"); }
+// debugging
+void print_block()                             PRODUCT_RETURN;
+void print_block(InstructionPrinter& ip, bool live_only = false) PRODUCT_RETURN;
+};
+BASE(BlockEnd, StateSplit)
+private:
+BlockList*  _sux;
+protected:
+BlockList* sux() const                         { return _sux; }
+void set_sux(BlockList* sux) {
+#ifdef ASSERT
+assert(sux != NULL, "sux must exist");
+for (int i = sux->length() - 1; i >= 0; i--) assert(sux->at(i) != NULL, "sux must exist");
+#endif
+_sux = sux;
+}
+public:
+// creation
+BlockEnd(ValueType* type, ValueStack* state_before, bool is_safepoint)
+: StateSplit(type, state_before)
+, _sux(NULL)
+{
+set_flag(IsSafepointFlag, is_safepoint);
+}
+// accessors
+bool is_safepoint() const                      { return check_flag(IsSafepointFlag); }
+// For compatibility with old code, for new code use block()
+BlockBegin* begin() const                      { return _block; }
+// manipulation
+void set_begin(BlockBegin* begin);
+// successors
+int number_of_sux() const                      { return _sux != NULL ? _sux->length() : 0; }
+BlockBegin* sux_at(int i) const                { return _sux->at(i); }
+BlockBegin* default_sux() const                { return sux_at(number_of_sux() - 1); }
+BlockBegin** addr_sux_at(int i) const          { return _sux->adr_at(i); }
+int sux_index(BlockBegin* sux) const           { return _sux->find(sux); }
+void substitute_sux(BlockBegin* old_sux, BlockBegin* new_sux);
+};
+LEAF(Goto, BlockEnd)
+public:
+enum Direction {
+none,            // Just a regular goto
+taken, not_taken // Goto produced from If
+};
+private:
+ciMethod*   _profiled_method;
+int         _profiled_bci;
+Direction   _direction;
+public:
+// creation
+Goto(BlockBegin* sux, ValueStack* state_before, bool is_safepoint = false)
+: BlockEnd(illegalType, state_before, is_safepoint)
+, _direction(none)
+, _profiled_method(NULL)
+, _profiled_bci(0) {
+BlockList* s = new BlockList(1);
+s->append(sux);
+set_sux(s);
+}
+Goto(BlockBegin* sux, bool is_safepoint) : BlockEnd(illegalType, NULL, is_safepoint)
+, _direction(none)
+, _profiled_method(NULL)
+, _profiled_bci(0) {
+BlockList* s = new BlockList(1);
+s->append(sux);
+set_sux(s);
+}
+bool should_profile() const                    { return check_flag(ProfileMDOFlag); }
+ciMethod* profiled_method() const              { return _profiled_method; } // set only for profiled branches
+int profiled_bci() const                       { return _profiled_bci; }
+Direction direction() const                    { return _direction; }
+void set_should_profile(bool value)            { set_flag(ProfileMDOFlag, value); }
+void set_profiled_method(ciMethod* method)     { _profiled_method = method; }
+void set_profiled_bci(int bci)                 { _profiled_bci = bci; }
+void set_direction(Direction d)                { _direction = d; }
+};
+#ifdef ASSERT
+LEAF(Assert, Instruction)
+private:
+Value       _x;
+Condition   _cond;
+Value       _y;
+char        *_message;
+public:
+// creation
+// unordered_is_true is valid for float/double compares only
+Assert(Value x, Condition cond, bool unordered_is_true, Value y);
+// accessors
+Value x() const                                { return _x; }
+Condition cond() const                         { return _cond; }
+bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
+Value y() const                                { return _y; }
+const char *message() const                    { return _message; }
+// generic
+virtual void input_values_do(ValueVisitor* f)  { f->visit(&_x); f->visit(&_y); }
+};
+#endif
+LEAF(RangeCheckPredicate, StateSplit)
+private:
+Value       _x;
+Condition   _cond;
+Value       _y;
+void check_state();
+public:
+// creation
+// unordered_is_true is valid for float/double compares only
+RangeCheckPredicate(Value x, Condition cond, bool unordered_is_true, Value y, ValueStack* state) : StateSplit(illegalType)
+, _x(x)
+, _cond(cond)
+, _y(y)
+{
+ASSERT_VALUES
+set_flag(UnorderedIsTrueFlag, unordered_is_true);
+assert(x->type()->tag() == y->type()->tag(), "types must match");
+this->set_state(state);
+check_state();
+}
+// Always deoptimize
+RangeCheckPredicate(ValueStack* state) : StateSplit(illegalType)
+{
+this->set_state(state);
+_x = _y = NULL;
+check_state();
+}
+// accessors
+Value x() const                                { return _x; }
+Condition cond() const                         { return _cond; }
+bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
+Value y() const                                { return _y; }
+void always_fail()                             { _x = _y = NULL; }
+// generic
+virtual void input_values_do(ValueVisitor* f)  { StateSplit::input_values_do(f); f->visit(&_x); f->visit(&_y); }
+HASHING3(RangeCheckPredicate, true, x()->subst(), y()->subst(), cond())
+};
+LEAF(If, BlockEnd)
+private:
+Value       _x;
+Condition   _cond;
+Value       _y;
+ciMethod*   _profiled_method;
+int         _profiled_bci; // Canonicalizer may alter bci of If node
+bool        _swapped;      // Is the order reversed with respect to the original If in the
+// bytecode stream?
+public:
+// creation
+// unordered_is_true is valid for float/double compares only
+If(Value x, Condition cond, bool unordered_is_true, Value y, BlockBegin* tsux, BlockBegin* fsux, ValueStack* state_before, bool is_safepoint)
+: BlockEnd(illegalType, state_before, is_safepoint)
+, _x(x)
+, _cond(cond)
+, _y(y)
+, _profiled_method(NULL)
+, _profiled_bci(0)
+, _swapped(false)
+{
+ASSERT_VALUES
+set_flag(UnorderedIsTrueFlag, unordered_is_true);
+assert(x->type()->tag() == y->type()->tag(), "types must match");
+BlockList* s = new BlockList(2);
+s->append(tsux);
+s->append(fsux);
+set_sux(s);
+}
+// accessors
+Value x() const                                { return _x; }
+Condition cond() const                         { return _cond; }
+bool unordered_is_true() const                 { return check_flag(UnorderedIsTrueFlag); }
+Value y() const                                { return _y; }
+BlockBegin* sux_for(bool is_true) const        { return sux_at(is_true ? 0 : 1); }
+BlockBegin* tsux() const                       { return sux_for(true); }
+BlockBegin* fsux() const                       { return sux_for(false); }
+BlockBegin* usux() const                       { return sux_for(unordered_is_true()); }
+bool should_profile() const                    { return check_flag(ProfileMDOFlag); }
+ciMethod* profiled_method() const              { return _profiled_method; } // set only for profiled branches
+int profiled_bci() const                       { return _profiled_bci; }    // set for profiled branches and tiered
+bool is_swapped() const                        { return _swapped; }
+// manipulation
+void swap_operands() {
+Value t = _x; _x = _y; _y = t;
+_cond = mirror(_cond);
+}
+void swap_sux() {
+assert(number_of_sux() == 2, "wrong number of successors");
+BlockList* s = sux();
+BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
+_cond = negate(_cond);
+set_flag(UnorderedIsTrueFlag, !check_flag(UnorderedIsTrueFlag));
+}
+void set_should_profile(bool value)             { set_flag(ProfileMDOFlag, value); }
+void set_profiled_method(ciMethod* method)      { _profiled_method = method; }
+void set_profiled_bci(int bci)                  { _profiled_bci = bci;       }
+void set_swapped(bool value)                    { _swapped = value;         }
+// generic
+virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_x); f->visit(&_y); }
+};
+LEAF(IfInstanceOf, BlockEnd)
+private:
+ciKlass* _klass;
+Value    _obj;
+bool     _test_is_instance;                    // jump if instance
+int      _instanceof_bci;
+public:
+IfInstanceOf(ciKlass* klass, Value obj, bool test_is_instance, int instanceof_bci, BlockBegin* tsux, BlockBegin* fsux)
+: BlockEnd(illegalType, NULL, false) // temporary set to false
+, _klass(klass)
+, _obj(obj)
+, _test_is_instance(test_is_instance)
+, _instanceof_bci(instanceof_bci)
+{
+ASSERT_VALUES
+assert(instanceof_bci >= 0, "illegal bci");
+BlockList* s = new BlockList(2);
+s->append(tsux);
+s->append(fsux);
+set_sux(s);
+}
+// accessors
+//
+// Note 1: If test_is_instance() is true, IfInstanceOf tests if obj *is* an
+//         instance of klass; otherwise it tests if it is *not* and instance
+//         of klass.
+//
+// Note 2: IfInstanceOf instructions are created by combining an InstanceOf
+//         and an If instruction. The IfInstanceOf bci() corresponds to the
+//         bci that the If would have had; the (this->) instanceof_bci() is
+//         the bci of the original InstanceOf instruction.
+ciKlass* klass() const                         { return _klass; }
+Value obj() const                              { return _obj; }
+int instanceof_bci() const                     { return _instanceof_bci; }
+bool test_is_instance() const                  { return _test_is_instance; }
+BlockBegin* sux_for(bool is_true) const        { return sux_at(is_true ? 0 : 1); }
+BlockBegin* tsux() const                       { return sux_for(true); }
+BlockBegin* fsux() const                       { return sux_for(false); }
+// manipulation
+void swap_sux() {
+assert(number_of_sux() == 2, "wrong number of successors");
+BlockList* s = sux();
+BlockBegin* t = s->at(0); s->at_put(0, s->at(1)); s->at_put(1, t);
+_test_is_instance = !_test_is_instance;
+}
+// generic
+virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_obj); }
+};
+BASE(Switch, BlockEnd)
+private:
+Value       _tag;
+public:
+// creation
+Switch(Value tag, BlockList* sux, ValueStack* state_before, bool is_safepoint)
+: BlockEnd(illegalType, state_before, is_safepoint)
+, _tag(tag) {
+ASSERT_VALUES
+set_sux(sux);
+}
+// accessors
+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); }
+};
+LEAF(TableSwitch, Switch)
+private:
+int _lo_key;
+public:
+// creation
+TableSwitch(Value tag, BlockList* sux, int lo_key, ValueStack* state_before, bool is_safepoint)
+: Switch(tag, sux, state_before, is_safepoint)
+, _lo_key(lo_key) {}
+// accessors
+int lo_key() const                             { return _lo_key; }
+int hi_key() const                             { return _lo_key + length() - 1; }
+};
+LEAF(LookupSwitch, Switch)
+private:
+intArray* _keys;
+public:
+// creation
+LookupSwitch(Value tag, BlockList* sux, intArray* keys, ValueStack* state_before, bool is_safepoint)
+: Switch(tag, sux, state_before, is_safepoint)
+, _keys(keys) {
+assert(keys != NULL, "keys must exist");
+assert(keys->length() == length(), "sux & keys have incompatible lengths");
+}
+// accessors
+int key_at(int i) const                        { return _keys->at(i); }
+};
+LEAF(Return, BlockEnd)
+private:
+Value _result;
+public:
+// creation
+Return(Value result) :
+BlockEnd(result == NULL ? voidType : result->type()->base(), NULL, true),
+_result(result) {}
+// accessors
+Value result() const                           { return _result; }
+bool has_result() const                        { return result() != NULL; }
+// generic
+virtual void input_values_do(ValueVisitor* f) {
+BlockEnd::input_values_do(f);
+if (has_result()) f->visit(&_result);
+}
+};
+LEAF(Throw, BlockEnd)
+private:
+Value _exception;
+public:
+// creation
+Throw(Value exception, ValueStack* state_before) : BlockEnd(illegalType, state_before, true), _exception(exception) {
+ASSERT_VALUES
+}
+// accessors
+Value exception() const                        { return _exception; }
+// generic
+virtual bool can_trap() const                  { return true; }
+virtual void input_values_do(ValueVisitor* f)   { BlockEnd::input_values_do(f); f->visit(&_exception); }
+};
+LEAF(Base, BlockEnd)
+public:
+// creation
+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);
+}
+// accessors
+BlockBegin* std_entry() const                  { return default_sux(); }
+BlockBegin* osr_entry() const                  { return number_of_sux() < 2 ? NULL : sux_at(0); }
+};
+LEAF(OsrEntry, Instruction)
+public:
+// creation
+#ifdef _LP64
+OsrEntry() : Instruction(longType) { pin(); }
+#else
+OsrEntry() : Instruction(intType)  { pin(); }
+#endif
+// generic
+virtual void input_values_do(ValueVisitor* f)   { }
+};
+// Models the incoming exception at a catch site
+LEAF(ExceptionObject, Instruction)
+public:
+// creation
+ExceptionObject() : Instruction(objectType) {
+pin();
+}
+// generic
+virtual void input_values_do(ValueVisitor* f)   { }
+};
+// Models needed rounding for floating-point values on Intel.
+// Currently only used to represent rounding of double-precision
+// values stored into local variables, but could be used to model
+// intermediate rounding of single-precision values as well.
+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
+}
+// accessors
+Value input() const                            { return _input; }
+// generic
+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:
+// creation
+UnsafeOp(BasicType basic_type, bool is_put)
+: Instruction(is_put ? voidType : as_ValueType(basic_type))
+, _basic_type(basic_type)
+{
+//Note:  Unsafe ops are not not guaranteed to throw NPE.
+// Convservatively, Unsafe operations must be pinned though we could be
+// looser about this if we wanted to..
+pin();
+}
+public:
+// accessors
+BasicType basic_type()                         { return _basic_type; }
+// generic
+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.
+// Indicates log2 of number of bytes (1, 2, 4, or 8)
+// to scale index by.
+protected:
+UnsafeRawOp(BasicType basic_type, Value addr, bool is_put)
+: UnsafeOp(basic_type, is_put)
+, _base(addr)
+, _index(NULL)
+, _log2_scale(0)
+{
+// Can not use ASSERT_VALUES because index may be NULL
+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:
+// accessors
+Value base()                                   { return _base; }
+Value index()                                  { return _index; }
+bool  has_index()                              { return (_index != NULL); }
+int   log2_scale()                             { return _log2_scale; }
+// setters
+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; }
+// generic
+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
+}
+// accessors
+Value value()                                  { return _value; }
+// generic
+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)
+{
+}
+// accessors
+Value object()                                 { return _object; }
+Value offset()                                 { return _offset; }
+bool  is_volatile()                            { return _is_volatile; }
+// generic
+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
+}
+// accessors
+Value value()                                  { return _value; }
+// generic
+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
+}
+// accessors
+bool is_add() const                            { return _is_add; }
+Value value()                                  { return _value; }
+// generic
+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)
+{
+// The ProfileCall has side-effects and must occur precisely where located
+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);
+// The ProfileType has side-effects and must occur precisely where located
+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);
+}
+}
+};
+// Call some C runtime function that doesn't safepoint,
+// optionally passing the current thread as the first argument.
+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));
+}
+};
+// Use to trip invocation counter of an inlined method
+LEAF(ProfileInvoke, Instruction)
+private:
+ciMethod*   _inlinee;
+ValueStack* _state;
+public:
+ProfileInvoke(ciMethod* inlinee,  ValueStack* state)
+: Instruction(voidType)
+, _inlinee(inlinee)
+, _state(state)
+{
+// The ProfileInvoke has side-effects and must occur precisely where located QQQ???
+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

comparison: src/share/vm/c1/c1_Instruction.hpp

src/share/vm/c1/c1_Instruction.hpp

Mercurial > jdk8-mips64-public > hotspot / file comparison

comparison: src/share/vm/c1/c1_Instruction.hpp

src/share/vm/c1/c1_Instruction.hpp