< prev index next >

src/share/vm/opto/memnode.hpp

Print this page

        

@@ -109,11 +109,11 @@
 #endif
   }
 
   // Map a load or store opcode to its corresponding store opcode.
   // (Return -1 if unknown.)
-  virtual int store_Opcode() const { return -1; }
+  virtual Opcodes store_Opcode() const { return Opcodes::MaxVal; }
 
   // What is the type of the value in memory?  (T_VOID mean "unspecified".)
   virtual BasicType memory_type() const = 0;
   virtual int memory_size() const {
 #ifdef ASSERT

@@ -196,12 +196,12 @@
   inline bool is_acquire() const {
     assert(_mo == unordered || _mo == acquire, "unexpected");
     return _mo == acquire;
   }
   inline bool is_unsigned() const {
-    int lop = Opcode();
-    return (lop == Op_LoadUB) || (lop == Op_LoadUS);
+    Opcodes lop = Opcode();
+    return (lop == Opcodes::Op_LoadUB) || (lop == Opcodes::Op_LoadUS);
   }
 
   // Polymorphic factory method:
   static Node* make(PhaseGVN& gvn, Node *c, Node *mem, Node *adr,
                     const TypePtr* at, const Type *rt, BasicType bt,

@@ -232,11 +232,11 @@
 
   // Common methods for LoadKlass and LoadNKlass nodes.
   const Type* klass_value_common(PhaseGVN* phase) const;
   Node* klass_identity_common(PhaseGVN* phase);
 
-  virtual uint ideal_reg() const;
+  virtual Opcodes ideal_reg() const;
   virtual const Type *bottom_type() const;
   // Following method is copied from TypeNode:
   void set_type(const Type* t) {
     assert(t != NULL, "sanity");
     debug_only(uint check_hash = (VerifyHashTableKeys && _hash_lock) ? hash() : NO_HASH);

@@ -248,11 +248,11 @@
 
   // Do not match memory edge
   virtual uint match_edge(uint idx) const;
 
   // Map a load opcode to its corresponding store opcode.
-  virtual int store_Opcode() const = 0;
+  virtual Opcodes 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);
 
   Node* convert_to_unsigned_load(PhaseGVN& gvn);

@@ -289,79 +289,79 @@
 // Load a byte (8bits signed) from memory
 class LoadBNode : public LoadNode {
 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 ideal_reg() const { return Op_RegI; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::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 Opcodes store_Opcode() const { return Opcodes::Op_StoreB; }
   virtual BasicType memory_type() const { return T_BYTE; }
 };
 
 //------------------------------LoadUBNode-------------------------------------
 // Load a unsigned byte (8bits unsigned) from memory
 class LoadUBNode : public LoadNode {
 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 ideal_reg() const { return Op_RegI; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::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 Opcodes store_Opcode() const { return Opcodes::Op_StoreB; }
   virtual BasicType memory_type() const { return T_BYTE; }
 };
 
 //------------------------------LoadUSNode-------------------------------------
 // Load an unsigned short/char (16bits unsigned) from memory
 class LoadUSNode : public LoadNode {
 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 ideal_reg() const { return Op_RegI; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::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 Opcodes store_Opcode() const { return Opcodes::Op_StoreC; }
   virtual BasicType memory_type() const { return T_CHAR; }
 };
 
 //------------------------------LoadSNode--------------------------------------
 // Load a short (16bits signed) from memory
 class LoadSNode : public LoadNode {
 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 ideal_reg() const { return Op_RegI; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::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 Opcodes store_Opcode() const { return Opcodes::Op_StoreC; }
   virtual BasicType memory_type() const { return T_SHORT; }
 };
 
 //------------------------------LoadINode--------------------------------------
 // Load an integer from memory
 class LoadINode : public LoadNode {
 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 ideal_reg() const { return Op_RegI; }
-  virtual int store_Opcode() const { return Op_StoreI; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegI; }
+  virtual Opcodes store_Opcode() const { return Opcodes::Op_StoreI; }
   virtual BasicType memory_type() const { return T_INT; }
 };
 
 //------------------------------LoadRangeNode----------------------------------
 // Load an array length from the array
 class LoadRangeNode : public LoadINode {
 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 Opcodes Opcode() const;
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 };
 

@@ -378,13 +378,13 @@
 
 public:
   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 ideal_reg() const { return Op_RegL; }
-  virtual int store_Opcode() const { return Op_StoreL; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegL; }
+  virtual Opcodes store_Opcode() const { return Opcodes::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,
                                 const Type* rt, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest,
                                 bool unaligned = false, bool mismatched = false);

@@ -400,22 +400,22 @@
 // Load a long from unaligned memory
 class LoadL_unalignedNode : public LoadLNode {
 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 Opcodes Opcode() const;
 };
 
 //------------------------------LoadFNode--------------------------------------
 // Load a float (64 bits) from memory
 class LoadFNode : public LoadNode {
 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 ideal_reg() const { return Op_RegF; }
-  virtual int store_Opcode() const { return Op_StoreF; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegF; }
+  virtual Opcodes store_Opcode() const { return Opcodes::Op_StoreF; }
   virtual BasicType memory_type() const { return T_FLOAT; }
 };
 
 //------------------------------LoadDNode--------------------------------------
 // Load a double (64 bits) from memory

@@ -430,13 +430,13 @@
 
 public:
   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 ideal_reg() const { return Op_RegD; }
-  virtual int store_Opcode() const { return Op_StoreD; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegD; }
+  virtual Opcodes store_Opcode() const { return Opcodes::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,
                                 const Type* rt, MemOrd mo, ControlDependency control_dependency = DependsOnlyOnTest,
                                 bool unaligned = false, bool mismatched = false);

@@ -452,35 +452,35 @@
 // Load a double from unaligned memory
 class LoadD_unalignedNode : public LoadDNode {
 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 Opcodes Opcode() const;
 };
 
 //------------------------------LoadPNode--------------------------------------
 // Load a pointer from memory (either object or array)
 class LoadPNode : public LoadNode {
 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 ideal_reg() const { return Op_RegP; }
-  virtual int store_Opcode() const { return Op_StoreP; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegP; }
+  virtual Opcodes store_Opcode() const { return Opcodes::Op_StoreP; }
   virtual BasicType memory_type() const { return T_ADDRESS; }
 };
 
 
 //------------------------------LoadNNode--------------------------------------
 // Load a narrow oop from memory (either object or array)
 class LoadNNode : public LoadNode {
 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 ideal_reg() const { return Op_RegN; }
-  virtual int store_Opcode() const { return Op_StoreN; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegN; }
+  virtual Opcodes store_Opcode() const { return Opcodes::Op_StoreN; }
   virtual BasicType memory_type() const { return T_NARROWOOP; }
 };
 
 //------------------------------LoadKlassNode----------------------------------
 // Load a Klass from an object

@@ -490,11 +490,11 @@
   // input is set, it must not be removed (by LoadNode::Ideal()).
   virtual bool can_remove_control() const;
 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 Opcodes Opcode() const;
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node* Identity(PhaseGVN* phase);
   virtual bool depends_only_on_test() const { return true; }
 
   // Polymorphic factory method:

@@ -506,13 +506,13 @@
 // Load a narrow Klass from an object.
 class LoadNKlassNode : public LoadNNode {
 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 ideal_reg() const { return Op_RegN; }
-  virtual int store_Opcode() const { return Op_StoreNKlass; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegN; }
+  virtual Opcodes store_Opcode() const { return Opcodes::Op_StoreNKlass; }
   virtual BasicType memory_type() const { return T_NARROWKLASS; }
 
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node* Identity(PhaseGVN* phase);
   virtual bool depends_only_on_test() const { return true; }

@@ -600,11 +600,11 @@
   virtual uint match_edge(uint idx) const;
 
   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 Opcodes store_Opcode() const { return Opcode(); }
 
   // have all possible loads of the value stored been optimized away?
   bool value_never_loaded(PhaseTransform *phase) const;
 };
 

@@ -612,33 +612,33 @@
 // Store byte to memory
 class StoreBNode : public StoreNode {
 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 Opcodes Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual BasicType memory_type() const { return T_BYTE; }
 };
 
 //------------------------------StoreCNode-------------------------------------
 // Store char/short to memory
 class StoreCNode : public StoreNode {
 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 Opcodes Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual BasicType memory_type() const { return T_CHAR; }
 };
 
 //------------------------------StoreINode-------------------------------------
 // Store int to memory
 class StoreINode : public StoreNode {
 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 Opcodes Opcode() const;
   virtual BasicType memory_type() const { return T_INT; }
 };
 
 //------------------------------StoreLNode-------------------------------------
 // Store long to memory

@@ -652,11 +652,11 @@
   const bool _require_atomic_access;  // is piecewise store forbidden?
 
 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 Opcodes 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);
 #ifndef PRODUCT
   virtual void dump_spec(outputStream *st) const {

@@ -670,11 +670,11 @@
 // Store float to memory
 class StoreFNode : public StoreNode {
 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 Opcodes Opcode() const;
   virtual BasicType memory_type() const { return T_FLOAT; }
 };
 
 //------------------------------StoreDNode-------------------------------------
 // Store double to memory

@@ -688,11 +688,11 @@
   const bool _require_atomic_access;  // is piecewise store forbidden?
 public:
   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 Opcodes 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);
 #ifndef PRODUCT
   virtual void dump_spec(outputStream *st) const {

@@ -707,31 +707,31 @@
 // Store pointer to memory
 class StorePNode : public StoreNode {
 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 Opcodes Opcode() const;
   virtual BasicType memory_type() const { return T_ADDRESS; }
 };
 
 //------------------------------StoreNNode-------------------------------------
 // Store narrow oop to memory
 class StoreNNode : public StoreNode {
 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 Opcodes Opcode() const;
   virtual BasicType memory_type() const { return T_NARROWOOP; }
 };
 
 //------------------------------StoreNKlassNode--------------------------------------
 // Store narrow klass to memory
 class StoreNKlassNode : public StoreNNode {
 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 Opcodes Opcode() const;
   virtual BasicType memory_type() const { return T_NARROWKLASS; }
 };
 
 //------------------------------StoreCMNode-----------------------------------
 // Store card-mark byte to memory for CM

@@ -753,11 +753,11 @@
     _oop_alias_idx(oop_alias_idx) {
     assert(_oop_alias_idx >= Compile::AliasIdxRaw ||
            _oop_alias_idx == Compile::AliasIdxBot && Compile::current()->AliasLevel() == 0,
            "bad oop alias idx");
   }
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual BasicType memory_type() const { return T_VOID; } // unspecific
   int oop_alias_idx() const { return _oop_alias_idx; }

@@ -769,31 +769,31 @@
 // On PowerPC and friends it's a real load-locked.
 class LoadPLockedNode : public LoadPNode {
 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 Opcodes Opcode() const;
+  virtual Opcodes store_Opcode() const { return Opcodes::Op_StorePConditional; }
   virtual bool depends_only_on_test() const { return true; }
 };
 
 //------------------------------SCMemProjNode---------------------------------------
 // This class defines a projection of the memory  state of a store conditional node.
 // These nodes return a value, but also update memory.
 class SCMemProjNode : public ProjNode {
 public:
   enum {SCMEMPROJCON = (uint)-2};
   SCMemProjNode( Node *src) : ProjNode( src, SCMEMPROJCON) { }
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual bool      is_CFG() const  { return false; }
   virtual const Type *bottom_type() const {return Type::MEMORY;}
   virtual const TypePtr *adr_type() const {
     Node* ctrl = in(0);
     if (ctrl == NULL)  return NULL; // node is dead
     return ctrl->in(MemNode::Memory)->adr_type();
   }
-  virtual uint ideal_reg() const { return 0;} // memory projections don't have a register
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_Node;} // memory projections don't have a register
   virtual const Type* Value(PhaseGVN* phase) const;
 #ifndef PRODUCT
   virtual void dump_spec(outputStream *st) const {};
 #endif
 };

@@ -809,11 +809,11 @@
   LoadStoreNode( Node *c, Node *mem, Node *adr, Node *val, const TypePtr* at, const Type* rt, uint required );
   virtual bool depends_only_on_test() const { return false; }
   virtual uint match_edge(uint idx) const { return idx == MemNode::Address || idx == MemNode::ValueIn; }
 
   virtual const Type *bottom_type() const { return _type; }
-  virtual uint ideal_reg() const;
+  virtual Opcodes ideal_reg() const;
   virtual const class TypePtr *adr_type() const { return _adr_type; }  // returns bottom_type of address
 
   bool result_not_used() const;
 };
 

@@ -829,35 +829,35 @@
 // Conditionally store pointer to memory, if no change since prior
 // load-locked.  Sets flags for success or failure of the store.
 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 Opcodes Opcode() const;
   // Produces flags
-  virtual uint ideal_reg() const { return Op_RegFlags; }
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegFlags; }
 };
 
 //------------------------------StoreIConditionalNode---------------------------
 // Conditionally store int to memory, if no change since prior
 // load-locked.  Sets flags for success or failure of the store.
 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 Opcodes Opcode() const;
   // Produces flags
-  virtual uint ideal_reg() const { return Op_RegFlags; }
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegFlags; }
 };
 
 //------------------------------StoreLConditionalNode---------------------------
 // Conditionally store long to memory, if no change since prior
 // load-locked.  Sets flags for success or failure of the store.
 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 Opcodes Opcode() const;
   // Produces flags
-  virtual uint ideal_reg() const { return Op_RegFlags; }
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_RegFlags; }
 };
 
 class CompareAndSwapNode : public LoadStoreConditionalNode {
 private:
   const MemNode::MemOrd _mem_ord;

@@ -887,203 +887,203 @@
 
 //------------------------------CompareAndSwapBNode---------------------------
 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes Opcode() const;
 };
 
 
 //------------------------------CompareAndExchangeSNode---------------------------
 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 Opcodes 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 Opcodes Opcode() const;
 };
 
 
 //------------------------------CompareAndExchangeINode---------------------------
 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 Opcodes Opcode() const;
 };
 
 
 //------------------------------CompareAndExchangePNode---------------------------
 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes 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 Opcodes Opcode() const;
 };
 
 //------------------------------ClearArray-------------------------------------
 class ClearArrayNode: public Node {
 private:

@@ -1091,11 +1091,11 @@
 public:
   ClearArrayNode( Node *ctrl, Node *arymem, Node *word_cnt, Node *base, bool is_large)
     : Node(ctrl,arymem,word_cnt,base), _is_large(is_large) {
     init_class_id(Class_ClearArray);
   }
-  virtual int         Opcode() const;
+  virtual Opcodes     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.
   virtual const class TypePtr *adr_type() const;
   virtual Node* Identity(PhaseGVN* phase);

@@ -1144,20 +1144,20 @@
 public:
   enum {
     Precedent = TypeFunc::Parms  // optional edge to force precedence
   };
   MemBarNode(Compile* C, int alias_idx, Node* precedent);
-  virtual int Opcode() const = 0;
+  virtual Opcodes 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);
   virtual uint match_edge(uint idx) const { return 0; }
   virtual const Type *bottom_type() const { return TypeTuple::MEMBAR; }
   virtual Node *match( const ProjNode *proj, const Matcher *m );
   // Factory method.  Builds a wide or narrow membar.
   // Optional 'precedent' becomes an extra edge if not null.
-  static MemBarNode* make(Compile* C, int opcode,
+  static MemBarNode* make(Compile* C, Opcodes opcode,
                           int alias_idx = Compile::AliasIdxBot,
                           Node* precedent = NULL);
 };
 
 // "Acquire" - no following ref can move before (but earlier refs can

@@ -1165,99 +1165,99 @@
 // visibility.  Inserted after a volatile load.
 class MemBarAcquireNode: public MemBarNode {
 public:
   MemBarAcquireNode(Compile* C, int alias_idx, Node* precedent)
     : MemBarNode(C, alias_idx, precedent) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 // "Acquire" - no following ref can move before (but earlier refs can
 // follow, like an early Load stalled in cache).  Requires multi-cpu
 // visibility.  Inserted independ of any load, as required
 // for intrinsic Unsafe.loadFence().
 class LoadFenceNode: public MemBarNode {
 public:
   LoadFenceNode(Compile* C, int alias_idx, Node* precedent)
     : MemBarNode(C, alias_idx, precedent) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 // "Release" - no earlier ref can move after (but later refs can move
 // up, like a speculative pipelined cache-hitting Load).  Requires
 // multi-cpu visibility.  Inserted before a volatile store.
 class MemBarReleaseNode: public MemBarNode {
 public:
   MemBarReleaseNode(Compile* C, int alias_idx, Node* precedent)
     : MemBarNode(C, alias_idx, precedent) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 // "Release" - no earlier ref can move after (but later refs can move
 // up, like a speculative pipelined cache-hitting Load).  Requires
 // multi-cpu visibility.  Inserted independent of any store, as required
 // for intrinsic Unsafe.storeFence().
 class StoreFenceNode: public MemBarNode {
 public:
   StoreFenceNode(Compile* C, int alias_idx, Node* precedent)
     : MemBarNode(C, alias_idx, precedent) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 // "Acquire" - no following ref can move before (but earlier refs can
 // follow, like an early Load stalled in cache).  Requires multi-cpu
 // visibility.  Inserted after a FastLock.
 class MemBarAcquireLockNode: public MemBarNode {
 public:
   MemBarAcquireLockNode(Compile* C, int alias_idx, Node* precedent)
     : MemBarNode(C, alias_idx, precedent) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 // "Release" - no earlier ref can move after (but later refs can move
 // up, like a speculative pipelined cache-hitting Load).  Requires
 // multi-cpu visibility.  Inserted before a FastUnLock.
 class MemBarReleaseLockNode: public MemBarNode {
 public:
   MemBarReleaseLockNode(Compile* C, int alias_idx, Node* precedent)
     : MemBarNode(C, alias_idx, precedent) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 class MemBarStoreStoreNode: public MemBarNode {
 public:
   MemBarStoreStoreNode(Compile* C, int alias_idx, Node* precedent)
     : MemBarNode(C, alias_idx, precedent) {
     init_class_id(Class_MemBarStoreStore);
   }
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 // Ordering between a volatile store and a following volatile load.
 // Requires multi-CPU visibility?
 class MemBarVolatileNode: public MemBarNode {
 public:
   MemBarVolatileNode(Compile* C, int alias_idx, Node* precedent)
     : MemBarNode(C, alias_idx, precedent) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 // Ordering within the same CPU.  Used to order unsafe memory references
 // inside the compiler when we lack alias info.  Not needed "outside" the
 // compiler because the CPU does all the ordering for us.
 class MemBarCPUOrderNode: public MemBarNode {
 public:
   MemBarCPUOrderNode(Compile* C, int alias_idx, Node* precedent)
     : MemBarNode(C, alias_idx, precedent) {}
-  virtual int Opcode() const;
-  virtual uint ideal_reg() const { return 0; } // not matched in the AD file
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_Node; } // not matched in the AD file
 };
 
 class OnSpinWaitNode: public MemBarNode {
 public:
   OnSpinWaitNode(Compile* C, int alias_idx, Node* precedent)
     : MemBarNode(C, alias_idx, precedent) {}
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
 };
 
 // Isolation of object setup after an AllocateNode and before next safepoint.
 // (See comment in memnode.cpp near InitializeNode::InitializeNode for semantics.)
 class InitializeNode: public MemBarNode {

@@ -1279,13 +1279,13 @@
     RawAddress = TypeFunc::Parms+0,    // the newly-allocated raw address
     RawStores  = TypeFunc::Parms+1     // zero or more stores (or TOP)
   };
 
   InitializeNode(Compile* C, int adr_type, Node* rawoop);
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual uint size_of() const { return sizeof(*this); }
-  virtual uint ideal_reg() const { return 0; } // not matched in the AD file
+  virtual Opcodes ideal_reg() const { return Opcodes::Op_Node; } // not matched in the AD file
   virtual const RegMask &in_RegMask(uint) const;  // mask for RawAddress
 
   // Manage incoming memory edges via a MergeMem on in(Memory):
   Node* memory(uint alias_idx);
 

@@ -1368,14 +1368,14 @@
   // If the input is a whole memory state, clone it with all its slices intact.
   // Otherwise, make a new memory state with just that base memory input.
   // In either case, the result is a newly created MergeMem.
   static MergeMemNode* make(Node* base_memory);
 
-  virtual int Opcode() const;
+  virtual Opcodes Opcode() const;
   virtual Node* Identity(PhaseGVN* phase);
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
-  virtual uint ideal_reg() const { return NotAMachineReg; }
+  virtual Opcodes ideal_reg() const { return Opcodes::NotAMachineReg; }
   virtual uint match_edge(uint idx) const { return 0; }
   virtual const RegMask &out_RegMask() const;
   virtual const Type *bottom_type() const { return Type::MEMORY; }
   virtual const TypePtr *adr_type() const { return TypePtr::BOTTOM; }
   // sparse accessors

@@ -1596,12 +1596,12 @@
 
 // Allocation prefetch which may fault, TLAB size have to be adjusted.
 class PrefetchAllocationNode : public Node {
 public:
   PrefetchAllocationNode(Node *mem, Node *adr) : Node(0,mem,adr) {}
-  virtual int Opcode() const;
-  virtual uint ideal_reg() const { return NotAMachineReg; }
+  virtual Opcodes Opcode() const;
+  virtual Opcodes ideal_reg() const { return Opcodes::NotAMachineReg; }
   virtual uint match_edge(uint idx) const { return idx==2; }
   virtual const Type *bottom_type() const { return ( AllocatePrefetchStyle == 3 ) ? Type::MEMORY : Type::ABIO; }
 };
 
 #endif // SHARE_VM_OPTO_MEMNODE_HPP
< prev index next >