--- old/src/share/vm/opto/memnode.hpp 2016-07-03 23:43:01.537504024 +0900 +++ new/src/share/vm/opto/memnode.hpp 2016-07-03 23:43:01.392504627 +0900 @@ -111,7 +111,7 @@ // Map a load or store opcode to its corresponding store opcode. // (Return -1 if unknown.) - virtual int store_Opcode() const { return -1; } + virtual uint store_Opcode() const { return ~0; } // What is the type of the value in memory? (T_VOID mean "unspecified".) virtual BasicType memory_type() const = 0; @@ -198,7 +198,7 @@ return _mo == acquire; } inline bool is_unsigned() const { - int lop = Opcode(); + uint lop = Opcode(); return (lop == Op_LoadUB) || (lop == Op_LoadUS); } @@ -250,7 +250,7 @@ virtual uint match_edge(uint idx) const; // Map a load opcode to its corresponding store opcode. - virtual int store_Opcode() const = 0; + virtual uint store_Opcode() const = 0; // Check if the load's memory input is a Phi node with the same control. bool is_instance_field_load_with_local_phi(Node* ctrl); @@ -291,11 +291,11 @@ public: LoadBNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) : LoadNode(c, mem, adr, at, ti, mo, control_dependency) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegI; } virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type* Value(PhaseGVN* phase) const; - virtual int store_Opcode() const { return Op_StoreB; } + virtual uint store_Opcode() const { return Op_StoreB; } virtual BasicType memory_type() const { return T_BYTE; } }; @@ -305,11 +305,11 @@ public: LoadUBNode(Node* c, Node* mem, Node* adr, const TypePtr* at, const TypeInt* ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) : LoadNode(c, mem, adr, at, ti, mo, control_dependency) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegI; } virtual Node* Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type* Value(PhaseGVN* phase) const; - virtual int store_Opcode() const { return Op_StoreB; } + virtual uint store_Opcode() const { return Op_StoreB; } virtual BasicType memory_type() const { return T_BYTE; } }; @@ -319,11 +319,11 @@ public: LoadUSNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) : LoadNode(c, mem, adr, at, ti, mo, control_dependency) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegI; } virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type* Value(PhaseGVN* phase) const; - virtual int store_Opcode() const { return Op_StoreC; } + virtual uint store_Opcode() const { return Op_StoreC; } virtual BasicType memory_type() const { return T_CHAR; } }; @@ -333,11 +333,11 @@ public: LoadSNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) : LoadNode(c, mem, adr, at, ti, mo, control_dependency) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegI; } virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type* Value(PhaseGVN* phase) const; - virtual int store_Opcode() const { return Op_StoreC; } + virtual uint store_Opcode() const { return Op_StoreC; } virtual BasicType memory_type() const { return T_SHORT; } }; @@ -347,9 +347,9 @@ public: LoadINode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeInt *ti, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) : LoadNode(c, mem, adr, at, ti, mo, control_dependency) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegI; } - virtual int store_Opcode() const { return Op_StoreI; } + virtual uint store_Opcode() const { return Op_StoreI; } virtual BasicType memory_type() const { return T_INT; } }; @@ -359,7 +359,7 @@ public: LoadRangeNode(Node *c, Node *mem, Node *adr, const TypeInt *ti = TypeInt::POS) : LoadINode(c, mem, adr, TypeAryPtr::RANGE, ti, MemNode::unordered) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual Node* Identity(PhaseGVN* phase); virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); @@ -380,9 +380,9 @@ LoadLNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const TypeLong *tl, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest, bool require_atomic_access = false) : LoadNode(c, mem, adr, at, tl, mo, control_dependency), _require_atomic_access(require_atomic_access) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegL; } - virtual int store_Opcode() const { return Op_StoreL; } + virtual uint store_Opcode() const { return Op_StoreL; } virtual BasicType memory_type() const { return T_LONG; } bool require_atomic_access() const { return _require_atomic_access; } static LoadLNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, @@ -402,7 +402,7 @@ public: LoadL_unalignedNode(Node *c, Node *mem, Node *adr, const TypePtr* at, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) : LoadLNode(c, mem, adr, at, TypeLong::LONG, mo, control_dependency) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------LoadFNode-------------------------------------- @@ -411,9 +411,9 @@ public: LoadFNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) : LoadNode(c, mem, adr, at, t, mo, control_dependency) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegF; } - virtual int store_Opcode() const { return Op_StoreF; } + virtual uint store_Opcode() const { return Op_StoreF; } virtual BasicType memory_type() const { return T_FLOAT; } }; @@ -432,9 +432,9 @@ LoadDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, const Type *t, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest, bool require_atomic_access = false) : LoadNode(c, mem, adr, at, t, mo, control_dependency), _require_atomic_access(require_atomic_access) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegD; } - virtual int store_Opcode() const { return Op_StoreD; } + virtual uint store_Opcode() const { return Op_StoreD; } virtual BasicType memory_type() const { return T_DOUBLE; } bool require_atomic_access() const { return _require_atomic_access; } static LoadDNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, @@ -454,7 +454,7 @@ public: LoadD_unalignedNode(Node *c, Node *mem, Node *adr, const TypePtr* at, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) : LoadDNode(c, mem, adr, at, Type::DOUBLE, mo, control_dependency) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------LoadPNode-------------------------------------- @@ -463,9 +463,9 @@ public: LoadPNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const TypePtr* t, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) : LoadNode(c, mem, adr, at, t, mo, control_dependency) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegP; } - virtual int store_Opcode() const { return Op_StoreP; } + virtual uint store_Opcode() const { return Op_StoreP; } virtual BasicType memory_type() const { return T_ADDRESS; } }; @@ -476,9 +476,9 @@ public: LoadNNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const Type* t, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest) : LoadNode(c, mem, adr, at, t, mo, control_dependency) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegN; } - virtual int store_Opcode() const { return Op_StoreN; } + virtual uint store_Opcode() const { return Op_StoreN; } virtual BasicType memory_type() const { return T_NARROWOOP; } }; @@ -492,7 +492,7 @@ public: LoadKlassNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const TypeKlassPtr *tk, MemOrd mo) : LoadPNode(c, mem, adr, at, tk, mo) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual Node* Identity(PhaseGVN* phase); virtual bool depends_only_on_test() const { return true; } @@ -508,9 +508,9 @@ public: LoadNKlassNode(Node *c, Node *mem, Node *adr, const TypePtr *at, const TypeNarrowKlass *tk, MemOrd mo) : LoadNNode(c, mem, adr, at, tk, mo) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegN; } - virtual int store_Opcode() const { return Op_StoreNKlass; } + virtual uint store_Opcode() const { return Op_StoreNKlass; } virtual BasicType memory_type() const { return T_NARROWKLASS; } virtual const Type* Value(PhaseGVN* phase) const; @@ -602,7 +602,7 @@ virtual const Type *bottom_type() const; // returns Type::MEMORY // Map a store opcode to its corresponding own opcode, trivially. - virtual int store_Opcode() const { return Opcode(); } + virtual uint store_Opcode() const { return Opcode(); } // have all possible loads of the value stored been optimized away? bool value_never_loaded(PhaseTransform *phase) const; @@ -614,7 +614,7 @@ public: StoreBNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) : StoreNode(c, mem, adr, at, val, mo) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual BasicType memory_type() const { return T_BYTE; } }; @@ -625,7 +625,7 @@ public: StoreCNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) : StoreNode(c, mem, adr, at, val, mo) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual BasicType memory_type() const { return T_CHAR; } }; @@ -636,7 +636,7 @@ public: StoreINode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) : StoreNode(c, mem, adr, at, val, mo) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual BasicType memory_type() const { return T_INT; } }; @@ -654,7 +654,7 @@ public: StoreLNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo, bool require_atomic_access = false) : StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual BasicType memory_type() const { return T_LONG; } bool require_atomic_access() const { return _require_atomic_access; } static StoreLNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo); @@ -672,7 +672,7 @@ public: StoreFNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) : StoreNode(c, mem, adr, at, val, mo) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual BasicType memory_type() const { return T_FLOAT; } }; @@ -690,7 +690,7 @@ StoreDNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo, bool require_atomic_access = false) : StoreNode(c, mem, adr, at, val, mo), _require_atomic_access(require_atomic_access) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual BasicType memory_type() const { return T_DOUBLE; } bool require_atomic_access() const { return _require_atomic_access; } static StoreDNode* make_atomic(Node* ctl, Node* mem, Node* adr, const TypePtr* adr_type, Node* val, MemOrd mo); @@ -709,7 +709,7 @@ public: StorePNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) : StoreNode(c, mem, adr, at, val, mo) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual BasicType memory_type() const { return T_ADDRESS; } }; @@ -719,7 +719,7 @@ public: StoreNNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) : StoreNode(c, mem, adr, at, val, mo) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual BasicType memory_type() const { return T_NARROWOOP; } }; @@ -729,7 +729,7 @@ public: StoreNKlassNode(Node *c, Node *mem, Node *adr, const TypePtr* at, Node *val, MemOrd mo) : StoreNNode(c, mem, adr, at, val, mo) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual BasicType memory_type() const { return T_NARROWKLASS; } }; @@ -755,7 +755,7 @@ _oop_alias_idx == Compile::AliasIdxBot && Compile::current()->AliasLevel() == 0, "bad oop alias idx"); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node* Identity(PhaseGVN* phase); virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type* Value(PhaseGVN* phase) const; @@ -771,8 +771,8 @@ public: LoadPLockedNode(Node *c, Node *mem, Node *adr, MemOrd mo) : LoadPNode(c, mem, adr, TypeRawPtr::BOTTOM, TypeRawPtr::BOTTOM, mo) {} - virtual int Opcode() const; - virtual int store_Opcode() const { return Op_StorePConditional; } + virtual uint Opcode() const; + virtual uint store_Opcode() const { return Op_StorePConditional; } virtual bool depends_only_on_test() const { return true; } }; @@ -783,7 +783,7 @@ public: enum {SCMEMPROJCON = (uint)-2}; SCMemProjNode( Node *src) : ProjNode( src, SCMEMPROJCON) { } - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool is_CFG() const { return false; } virtual const Type *bottom_type() const {return Type::MEMORY;} virtual const TypePtr *adr_type() const { @@ -831,7 +831,7 @@ class StorePConditionalNode : public LoadStoreConditionalNode { public: StorePConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ll ) : LoadStoreConditionalNode(c, mem, adr, val, ll) { } - virtual int Opcode() const; + virtual uint Opcode() const; // Produces flags virtual uint ideal_reg() const { return Op_RegFlags; } }; @@ -842,7 +842,7 @@ class StoreIConditionalNode : public LoadStoreConditionalNode { public: StoreIConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ii ) : LoadStoreConditionalNode(c, mem, adr, val, ii) { } - virtual int Opcode() const; + virtual uint Opcode() const; // Produces flags virtual uint ideal_reg() const { return Op_RegFlags; } }; @@ -853,7 +853,7 @@ class StoreLConditionalNode : public LoadStoreConditionalNode { public: StoreLConditionalNode( Node *c, Node *mem, Node *adr, Node *val, Node *ll ) : LoadStoreConditionalNode(c, mem, adr, val, ll) { } - virtual int Opcode() const; + virtual uint Opcode() const; // Produces flags virtual uint ideal_reg() const { return Op_RegFlags; } }; @@ -889,91 +889,91 @@ class CompareAndSwapBNode : public CompareAndSwapNode { public: CompareAndSwapBNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------CompareAndSwapSNode--------------------------- class CompareAndSwapSNode : public CompareAndSwapNode { public: CompareAndSwapSNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------CompareAndSwapINode--------------------------- class CompareAndSwapINode : public CompareAndSwapNode { public: CompareAndSwapINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------CompareAndSwapLNode--------------------------- class CompareAndSwapLNode : public CompareAndSwapNode { public: CompareAndSwapLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------CompareAndSwapPNode--------------------------- class CompareAndSwapPNode : public CompareAndSwapNode { public: CompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------CompareAndSwapNNode--------------------------- class CompareAndSwapNNode : public CompareAndSwapNode { public: CompareAndSwapNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------WeakCompareAndSwapBNode--------------------------- class WeakCompareAndSwapBNode : public CompareAndSwapNode { public: WeakCompareAndSwapBNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------WeakCompareAndSwapSNode--------------------------- class WeakCompareAndSwapSNode : public CompareAndSwapNode { public: WeakCompareAndSwapSNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------WeakCompareAndSwapINode--------------------------- class WeakCompareAndSwapINode : public CompareAndSwapNode { public: WeakCompareAndSwapINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------WeakCompareAndSwapLNode--------------------------- class WeakCompareAndSwapLNode : public CompareAndSwapNode { public: WeakCompareAndSwapLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------WeakCompareAndSwapPNode--------------------------- class WeakCompareAndSwapPNode : public CompareAndSwapNode { public: WeakCompareAndSwapPNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------WeakCompareAndSwapNNode--------------------------- class WeakCompareAndSwapNNode : public CompareAndSwapNode { public: WeakCompareAndSwapNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, MemNode::MemOrd mem_ord) : CompareAndSwapNode(c, mem, adr, val, ex, mem_ord) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------CompareAndExchangeBNode--------------------------- class CompareAndExchangeBNode : public CompareAndExchangeNode { public: CompareAndExchangeBNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, TypeInt::BYTE) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; @@ -981,14 +981,14 @@ class CompareAndExchangeSNode : public CompareAndExchangeNode { public: CompareAndExchangeSNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, TypeInt::SHORT) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------CompareAndExchangeLNode--------------------------- class CompareAndExchangeLNode : public CompareAndExchangeNode { public: CompareAndExchangeLNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, TypeLong::LONG) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; @@ -996,7 +996,7 @@ class CompareAndExchangeINode : public CompareAndExchangeNode { public: CompareAndExchangeINode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, TypeInt::INT) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; @@ -1004,84 +1004,84 @@ class CompareAndExchangePNode : public CompareAndExchangeNode { public: CompareAndExchangePNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, const Type* t, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, t) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------CompareAndExchangeNNode--------------------------- class CompareAndExchangeNNode : public CompareAndExchangeNode { public: CompareAndExchangeNNode( Node *c, Node *mem, Node *adr, Node *val, Node *ex, const TypePtr* at, const Type* t, MemNode::MemOrd mem_ord) : CompareAndExchangeNode(c, mem, adr, val, ex, mem_ord, at, t) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------GetAndAddBNode--------------------------- class GetAndAddBNode : public LoadStoreNode { public: GetAndAddBNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::BYTE, 4) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------GetAndAddSNode--------------------------- class GetAndAddSNode : public LoadStoreNode { public: GetAndAddSNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::SHORT, 4) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------GetAndAddINode--------------------------- class GetAndAddINode : public LoadStoreNode { public: GetAndAddINode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::INT, 4) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------GetAndAddLNode--------------------------- class GetAndAddLNode : public LoadStoreNode { public: GetAndAddLNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeLong::LONG, 4) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------GetAndSetBNode--------------------------- class GetAndSetBNode : public LoadStoreNode { public: GetAndSetBNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::BYTE, 4) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------GetAndSetSNode--------------------------- class GetAndSetSNode : public LoadStoreNode { public: GetAndSetSNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::SHORT, 4) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------GetAndSetINode--------------------------- class GetAndSetINode : public LoadStoreNode { public: GetAndSetINode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeInt::INT, 4) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------GetAndSetLNode--------------------------- class GetAndSetLNode : public LoadStoreNode { public: GetAndSetLNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at ) : LoadStoreNode(c, mem, adr, val, at, TypeLong::LONG, 4) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------GetAndSetPNode--------------------------- class GetAndSetPNode : public LoadStoreNode { public: GetAndSetPNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* t ) : LoadStoreNode(c, mem, adr, val, at, t, 4) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------GetAndSetNNode--------------------------- class GetAndSetNNode : public LoadStoreNode { public: GetAndSetNNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* t ) : LoadStoreNode(c, mem, adr, val, at, t, 4) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------ClearArray------------------------------------- @@ -1093,7 +1093,7 @@ : Node(ctrl,arymem,word_cnt,base), _is_large(is_large) { init_class_id(Class_ClearArray); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::MEMORY; } // ClearArray modifies array elements, and so affects only the // array memory addressed by the bottom_type of its base address. @@ -1146,7 +1146,7 @@ Precedent = TypeFunc::Parms // optional edge to force precedence }; MemBarNode(Compile* C, int alias_idx, Node* precedent); - virtual int Opcode() const = 0; + virtual uint Opcode() const = 0; virtual const class TypePtr *adr_type() const { return _adr_type; } virtual const Type* Value(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); @@ -1167,7 +1167,7 @@ public: MemBarAcquireNode(Compile* C, int alias_idx, Node* precedent) : MemBarNode(C, alias_idx, precedent) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; // "Acquire" - no following ref can move before (but earlier refs can @@ -1178,7 +1178,7 @@ public: LoadFenceNode(Compile* C, int alias_idx, Node* precedent) : MemBarNode(C, alias_idx, precedent) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; // "Release" - no earlier ref can move after (but later refs can move @@ -1188,7 +1188,7 @@ public: MemBarReleaseNode(Compile* C, int alias_idx, Node* precedent) : MemBarNode(C, alias_idx, precedent) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; // "Release" - no earlier ref can move after (but later refs can move @@ -1199,7 +1199,7 @@ public: StoreFenceNode(Compile* C, int alias_idx, Node* precedent) : MemBarNode(C, alias_idx, precedent) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; // "Acquire" - no following ref can move before (but earlier refs can @@ -1209,7 +1209,7 @@ public: MemBarAcquireLockNode(Compile* C, int alias_idx, Node* precedent) : MemBarNode(C, alias_idx, precedent) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; // "Release" - no earlier ref can move after (but later refs can move @@ -1219,7 +1219,7 @@ public: MemBarReleaseLockNode(Compile* C, int alias_idx, Node* precedent) : MemBarNode(C, alias_idx, precedent) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; class MemBarStoreStoreNode: public MemBarNode { @@ -1228,7 +1228,7 @@ : MemBarNode(C, alias_idx, precedent) { init_class_id(Class_MemBarStoreStore); } - virtual int Opcode() const; + virtual uint Opcode() const; }; // Ordering between a volatile store and a following volatile load. @@ -1237,7 +1237,7 @@ public: MemBarVolatileNode(Compile* C, int alias_idx, Node* precedent) : MemBarNode(C, alias_idx, precedent) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; // Ordering within the same CPU. Used to order unsafe memory references @@ -1247,7 +1247,7 @@ public: MemBarCPUOrderNode(Compile* C, int alias_idx, Node* precedent) : MemBarNode(C, alias_idx, precedent) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return 0; } // not matched in the AD file }; @@ -1255,7 +1255,7 @@ public: OnSpinWaitNode(Compile* C, int alias_idx, Node* precedent) : MemBarNode(C, alias_idx, precedent) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; // Isolation of object setup after an AllocateNode and before next safepoint. @@ -1281,7 +1281,7 @@ }; InitializeNode(Compile* C, int adr_type, Node* rawoop); - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint size_of() const { return sizeof(*this); } virtual uint ideal_reg() const { return 0; } // not matched in the AD file virtual const RegMask &in_RegMask(uint) const; // mask for RawAddress @@ -1370,7 +1370,7 @@ // In either case, the result is a newly created MergeMem. static MergeMemNode* make(Node* base_memory); - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node* Identity(PhaseGVN* phase); virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual uint ideal_reg() const { return NotAMachineReg; } @@ -1598,7 +1598,7 @@ class PrefetchAllocationNode : public Node { public: PrefetchAllocationNode(Node *mem, Node *adr) : Node(0,mem,adr) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return NotAMachineReg; } virtual uint match_edge(uint idx) const { return idx==2; } virtual const Type *bottom_type() const { return ( AllocatePrefetchStyle == 3 ) ? Type::MEMORY : Type::ABIO; }