< prev index next >

src/share/vm/opto/callnode.hpp

Print this page

        

@@ -70,11 +70,11 @@
   StartNode( Node *root, const TypeTuple *domain ) : MultiNode(2), _domain(domain) {
     init_class_id(Class_Start);
     init_req(0,this);
     init_req(1,root);
   }
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual bool pinned() const { return true; };
   virtual const Type *bottom_type() const;
   virtual const TypePtr *adr_type() const { return TypePtr::BOTTOM; }
   virtual const Type* Value(PhaseGVN* phase) const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);

@@ -91,11 +91,11 @@
 //------------------------------StartOSRNode-----------------------------------
 // The method start node for on stack replacement code
 class StartOSRNode : public StartNode {
 public:
   StartOSRNode( Node *root, const TypeTuple *domain ) : StartNode(root, domain) {}
-  virtual int   Opcode() const;
+  virtual uint   Opcode() const;
   static  const TypeTuple *osr_domain();
 };
 
 
 //------------------------------ParmNode---------------------------------------

@@ -104,11 +104,11 @@
   static const char * const names[TypeFunc::Parms+1];
 public:
   ParmNode( StartNode *src, uint con ) : ProjNode(src,con) {
     init_class_id(Class_Parm);
   }
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual bool  is_CFG() const { return (_con == TypeFunc::Control); }
   virtual uint ideal_reg() const;
 #ifndef PRODUCT
   virtual void dump_spec(outputStream *st) const;
   virtual void dump_compact_spec(outputStream *st) const;

@@ -120,11 +120,11 @@
 //------------------------------ReturnNode-------------------------------------
 // Return from subroutine node
 class ReturnNode : public Node {
 public:
   ReturnNode( uint edges, Node *cntrl, Node *i_o, Node *memory, Node *retadr, Node *frameptr );
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual bool  is_CFG() const { return true; }
   virtual uint hash() const { return NO_HASH; }  // CFG nodes do not hash
   virtual bool depends_only_on_test() const { return false; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type* Value(PhaseGVN* phase) const;

@@ -141,11 +141,11 @@
 // ends the current basic block like a ReturnNode.  Restores registers and
 // unwinds stack.  Rethrow happens in the caller's method.
 class RethrowNode : public Node {
  public:
   RethrowNode( Node *cntrl, Node *i_o, Node *memory, Node *frameptr, Node *ret_adr, Node *exception );
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual bool  is_CFG() const { return true; }
   virtual uint hash() const { return NO_HASH; }  // CFG nodes do not hash
   virtual bool depends_only_on_test() const { return false; }
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
   virtual const Type* Value(PhaseGVN* phase) const;

@@ -165,11 +165,11 @@
     : ReturnNode( TypeFunc::Parms+2, cntrl, i_o, memory, frameptr, retadr ) {
     init_req(TypeFunc::Parms, target);
     init_req(TypeFunc::Parms+1, moop);
   }
 
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual uint match_edge(uint idx) const;
 };
 
 //------------------------------TailJumpNode-----------------------------------
 // Pop stack frame and jump indirect

@@ -179,11 +179,11 @@
     : ReturnNode(TypeFunc::Parms+2, cntrl, i_o, memory, frameptr, Compile::current()->top()) {
     init_req(TypeFunc::Parms, target);
     init_req(TypeFunc::Parms+1, ex_oop);
   }
 
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual uint match_edge(uint idx) const;
 };
 
 //-------------------------------JVMState-------------------------------------
 // A linked list of JVMState nodes captures the whole interpreter state,

@@ -461,11 +461,11 @@
   bool has_replaced_nodes() const {
     return !_replaced_nodes.is_empty();
   }
 
   // Standard Node stuff
-  virtual int            Opcode() const;
+  virtual uint           Opcode() const;
   virtual bool           pinned() const { return true; }
   virtual const Type*    Value(PhaseGVN* phase) const;
   virtual const Type    *bottom_type() const { return Type::CONTROL; }
   virtual const TypePtr *adr_type() const { return _adr_type; }
   virtual Node          *Ideal(PhaseGVN *phase, bool can_reshape);

@@ -503,11 +503,11 @@
   SafePointScalarObjectNode(const TypeOopPtr* tp,
 #ifdef ASSERT
                             AllocateNode* alloc,
 #endif
                             uint first_index, uint n_fields);
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual uint           ideal_reg() const;
   virtual const RegMask &in_RegMask(uint) const;
   virtual const RegMask &out_RegMask() const;
   virtual uint           match_edge(uint idx) const;
 

@@ -669,11 +669,11 @@
       _override_symbolic_info(false)
   {
     init_class_id(Class_CallJava);
   }
 
-  virtual int   Opcode() const;
+  virtual uint   Opcode() const;
   ciMethod* method() const                 { return _method; }
   void  set_method(ciMethod *m)            { _method = m; }
   void  set_optimized_virtual(bool f)      { _optimized_virtual = f; }
   bool  is_optimized_virtual() const       { return _optimized_virtual; }
   void  set_method_handle_invoke(bool f)   { _method_handle_invoke = f; }

@@ -734,11 +734,11 @@
       set_jvms(jvms()->clone_deep(C));
       jvms()->set_map_deep(this);
     }
   }
 
-  virtual int         Opcode() const;
+  virtual uint        Opcode() const;
 #ifndef PRODUCT
   virtual void        dump_spec(outputStream *st) const;
   virtual void        dump_compact_spec(outputStream *st) const;
 #endif
 };

@@ -752,11 +752,11 @@
   CallDynamicJavaNode( const TypeFunc *tf , address addr, ciMethod* method, int vtable_index, int bci ) : CallJavaNode(tf,addr,method,bci), _vtable_index(vtable_index) {
     init_class_id(Class_CallDynamicJava);
   }
 
   int _vtable_index;
-  virtual int   Opcode() const;
+  virtual uint  Opcode() const;
 #ifndef PRODUCT
   virtual void  dump_spec(outputStream *st) const;
 #endif
 };
 

@@ -772,11 +772,11 @@
   {
     init_class_id(Class_CallRuntime);
     _name = name;
   }
 
-  virtual int   Opcode() const;
+  virtual uint  Opcode() const;
   virtual void  calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const;
 
 #ifndef PRODUCT
   virtual void  dump_spec(outputStream *st) const;
 #endif

@@ -791,11 +791,11 @@
                const TypePtr* adr_type)
     : CallRuntimeNode(tf, addr, name, adr_type)
   {
     init_class_id(Class_CallLeaf);
   }
-  virtual int   Opcode() const;
+  virtual uint  Opcode() const;
   virtual bool        guaranteed_safepoint()  { return false; }
 #ifndef PRODUCT
   virtual void  dump_spec(outputStream *st) const;
 #endif
 };

@@ -808,11 +808,11 @@
   CallLeafNoFPNode(const TypeFunc* tf, address addr, const char* name,
                    const TypePtr* adr_type)
     : CallLeafNode(tf, addr, name, adr_type)
   {
   }
-  virtual int   Opcode() const;
+  virtual uint   Opcode() const;
 };
 
 
 //------------------------------Allocate---------------------------------------
 // High-level memory allocation

@@ -869,11 +869,11 @@
     if (jvms() != NULL) {
       set_jvms(jvms()->clone_deep(C));
       jvms()->set_map_deep(this);
     }
   }
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual uint ideal_reg() const { return Op_RegP; }
   virtual bool        guaranteed_safepoint()  { return false; }
 
   // allocations do not modify their arguments
   virtual bool        may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase) { return false;}

@@ -948,11 +948,11 @@
                    initial_test)
   {
     init_class_id(Class_AllocateArray);
     set_req(AllocateNode::ALength,        count_val);
   }
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
 
   // Dig the length operand out of a array allocation site.
   Node* Ideal_length() {
     return in(AllocateNode::ALength);

@@ -1007,11 +1007,11 @@
   {
 #ifndef PRODUCT
     _counter = NULL;
 #endif
   }
-  virtual int Opcode() const = 0;
+  virtual uint Opcode() const = 0;
   Node *   obj_node() const       {return in(TypeFunc::Parms + 0); }
   Node *   box_node() const       {return in(TypeFunc::Parms + 1); }
   Node *   fastlock_node() const  {return in(TypeFunc::Parms + 2); }
   void     set_box_node(Node* box) { set_req(TypeFunc::Parms + 1, box); }
 

@@ -1069,11 +1069,11 @@
     const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
 
     return TypeFunc::make(domain,range);
   }
 
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual uint size_of() const; // Size is bigger
   LockNode(Compile* C, const TypeFunc *tf) : AbstractLockNode( tf ) {
     init_class_id(Class_Lock);
     init_flags(Flag_is_macro);
     C->add_macro_node(this);

@@ -1099,11 +1099,11 @@
 private:
 #ifdef ASSERT
   JVMState* const _dbg_jvms;      // Pointer to list of JVM State objects
 #endif
 public:
-  virtual int Opcode() const;
+  virtual uint Opcode() const;
   virtual uint size_of() const; // Size is bigger
   UnlockNode(Compile* C, const TypeFunc *tf) : AbstractLockNode( tf )
 #ifdef ASSERT
     , _dbg_jvms(NULL)
 #endif
< prev index next >