--- old/src/share/vm/adlc/output_c.cpp 2016-07-03 23:42:48.679557465 +0900 +++ new/src/share/vm/adlc/output_c.cpp 2016-07-03 23:42:48.536558060 +0900 @@ -4097,7 +4097,7 @@ // instruction has a matching rule for the host architecture. void ArchDesc::buildInstructMatchCheck(FILE *fp_cpp) const { fprintf(fp_cpp, "\n\n"); - fprintf(fp_cpp, "const bool Matcher::has_match_rule(int opcode) {\n"); + fprintf(fp_cpp, "const bool Matcher::has_match_rule(uint opcode) {\n"); fprintf(fp_cpp, " assert(_last_machine_leaf < opcode && opcode < _last_opcode, \"opcode in range\");\n"); fprintf(fp_cpp, " return _hasMatchRule[opcode];\n"); fprintf(fp_cpp, "}\n\n"); @@ -4156,11 +4156,11 @@ fprintf(fp_cpp,"%s\n", _frame->_c_calling_convention); fprintf(fp_cpp,"}\n\n"); // Java Return Value Location - fprintf(fp_cpp,"OptoRegPair Matcher::return_value(int ideal_reg, bool is_outgoing) {\n"); + fprintf(fp_cpp,"OptoRegPair Matcher::return_value(uint ideal_reg, bool is_outgoing) {\n"); fprintf(fp_cpp,"%s\n", _frame->_return_value); fprintf(fp_cpp,"}\n\n"); // Native Return Value Location - fprintf(fp_cpp,"OptoRegPair Matcher::c_return_value(int ideal_reg, bool is_outgoing) {\n"); + fprintf(fp_cpp,"OptoRegPair Matcher::c_return_value(uint ideal_reg, bool is_outgoing) {\n"); fprintf(fp_cpp,"%s\n", _frame->_c_return_value); fprintf(fp_cpp,"}\n\n"); --- old/src/share/vm/opto/addnode.hpp 2016-07-03 23:42:49.593553666 +0900 +++ new/src/share/vm/opto/addnode.hpp 2016-07-03 23:42:49.444554286 +0900 @@ -75,7 +75,7 @@ class AddINode : public AddNode { public: AddINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *add_ring( const Type *, const Type * ) const; virtual const Type *add_id() const { return TypeInt::ZERO; } virtual const Type *bottom_type() const { return TypeInt::INT; } @@ -89,7 +89,7 @@ class AddLNode : public AddNode { public: AddLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *add_ring( const Type *, const Type * ) const; virtual const Type *add_id() const { return TypeLong::ZERO; } virtual const Type *bottom_type() const { return TypeLong::LONG; } @@ -103,7 +103,7 @@ class AddFNode : public AddNode { public: AddFNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const; virtual const Type *add_ring( const Type *, const Type * ) const; @@ -118,7 +118,7 @@ class AddDNode : public AddNode { public: AddDNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *add_of_identity( const Type *t1, const Type *t2 ) const; virtual const Type *add_ring( const Type *, const Type * ) const; @@ -141,7 +141,7 @@ AddPNode( Node *base, Node *ptr, Node *off ) : Node(0,base,ptr,off) { init_class_id(Class_AddP); } - 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; @@ -166,7 +166,7 @@ class OrINode : public AddNode { public: OrINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *add_ring( const Type *, const Type * ) const; virtual const Type *add_id() const { return TypeInt::ZERO; } virtual const Type *bottom_type() const { return TypeInt::INT; } @@ -180,7 +180,7 @@ class OrLNode : public AddNode { public: OrLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *add_ring( const Type *, const Type * ) const; virtual const Type *add_id() const { return TypeLong::ZERO; } virtual const Type *bottom_type() const { return TypeLong::LONG; } @@ -193,7 +193,7 @@ class XorINode : public AddNode { public: XorINode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *add_ring( const Type *, const Type * ) const; virtual const Type *add_id() const { return TypeInt::ZERO; } virtual const Type *bottom_type() const { return TypeInt::INT; } @@ -205,7 +205,7 @@ class XorLNode : public AddNode { public: XorLNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *add_ring( const Type *, const Type * ) const; virtual const Type *add_id() const { return TypeLong::ZERO; } virtual const Type *bottom_type() const { return TypeLong::LONG; } @@ -219,7 +219,7 @@ class MaxNode : public AddNode { public: MaxNode( Node *in1, Node *in2 ) : AddNode(in1,in2) {} - virtual int Opcode() const = 0; + virtual uint Opcode() const = 0; }; //------------------------------MaxINode--------------------------------------- @@ -228,7 +228,7 @@ class MaxINode : public MaxNode { public: MaxINode( Node *in1, Node *in2 ) : MaxNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *add_ring( const Type *, const Type * ) const; virtual const Type *add_id() const { return TypeInt::make(min_jint); } virtual const Type *bottom_type() const { return TypeInt::INT; } @@ -241,7 +241,7 @@ class MinINode : public MaxNode { public: MinINode( Node *in1, Node *in2 ) : MaxNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *add_ring( const Type *, const Type * ) const; virtual const Type *add_id() const { return TypeInt::make(max_jint); } virtual const Type *bottom_type() const { return TypeInt::INT; } --- old/src/share/vm/opto/arraycopynode.hpp 2016-07-03 23:42:50.130551435 +0900 +++ new/src/share/vm/opto/arraycopynode.hpp 2016-07-03 23:42:49.990552016 +0900 @@ -153,7 +153,7 @@ void set_copyof(bool validated) { assert(_kind == None, "shouldn't bet set yet"); _kind = CopyOf; _arguments_validated = validated; } void set_copyofrange(bool validated) { assert(_kind == None, "shouldn't bet set yet"); _kind = CopyOfRange; _arguments_validated = validated; } - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint size_of() const; // Size is bigger virtual bool guaranteed_safepoint() { return false; } virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); --- old/src/share/vm/opto/callnode.hpp 2016-07-03 23:42:50.664549215 +0900 +++ new/src/share/vm/opto/callnode.hpp 2016-07-03 23:42:50.526549789 +0900 @@ -72,7 +72,7 @@ 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; } @@ -93,7 +93,7 @@ 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(); }; @@ -106,7 +106,7 @@ 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 @@ -122,7 +122,7 @@ 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; } @@ -143,7 +143,7 @@ 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; } @@ -167,7 +167,7 @@ init_req(TypeFunc::Parms+1, moop); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint match_edge(uint idx) const; }; @@ -181,7 +181,7 @@ init_req(TypeFunc::Parms+1, ex_oop); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint match_edge(uint idx) const; }; @@ -463,7 +463,7 @@ } // 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; } @@ -505,7 +505,7 @@ 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; @@ -671,7 +671,7 @@ 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; } @@ -736,7 +736,7 @@ } } - 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; @@ -754,7 +754,7 @@ } int _vtable_index; - virtual int Opcode() const; + virtual uint Opcode() const; #ifndef PRODUCT virtual void dump_spec(outputStream *st) const; #endif @@ -774,7 +774,7 @@ _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 @@ -793,7 +793,7 @@ { 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; @@ -810,7 +810,7 @@ : CallLeafNode(tf, addr, name, adr_type) { } - virtual int Opcode() const; + virtual uint Opcode() const; }; @@ -871,7 +871,7 @@ 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; } @@ -950,7 +950,7 @@ 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. @@ -1009,7 +1009,7 @@ _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); } @@ -1071,7 +1071,7 @@ 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); @@ -1101,7 +1101,7 @@ 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 --- old/src/share/vm/opto/castnode.cpp 2016-07-03 23:42:51.242546813 +0900 +++ new/src/share/vm/opto/castnode.cpp 2016-07-03 23:42:51.105547382 +0900 @@ -111,7 +111,7 @@ TypeNode* ConstraintCastNode::dominating_cast(PhaseTransform *phase) const { Node* val = in(1); Node* ctl = in(0); - int opc = Opcode(); + uint opc = Opcode(); if (ctl == NULL) { return NULL; } --- old/src/share/vm/opto/castnode.hpp 2016-07-03 23:42:51.785544556 +0900 +++ new/src/share/vm/opto/castnode.hpp 2016-07-03 23:42:51.646545134 +0900 @@ -47,7 +47,7 @@ virtual Node* Identity(PhaseGVN* phase); virtual const Type* Value(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const = 0; virtual bool depends_only_on_test() const { return !_carry_dependency; } bool carry_dependency() const { return _carry_dependency; } @@ -73,7 +73,7 @@ : ConstraintCastNode(n, t, carry_dependency), _range_check_dependency(range_check_dependency) { init_class_id(Class_CastII); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegI; } virtual const Type* Value(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); @@ -98,7 +98,7 @@ CastPPNode (Node *n, const Type *t, bool carry_dependency = false) : ConstraintCastNode(n, t, carry_dependency) { } - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegP; } }; @@ -114,7 +114,7 @@ virtual Node* Identity(PhaseGVN* phase); virtual const Type* Value(PhaseGVN* phase) const; - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegP; } }; @@ -124,7 +124,7 @@ class CastX2PNode : public Node { public: CastX2PNode( Node *n ) : Node(NULL, n) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual Node* Identity(PhaseGVN* phase); @@ -138,7 +138,7 @@ class CastP2XNode : public Node { public: CastP2XNode( Node *ctrl, Node *n ) : Node(ctrl, n) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual Node* Identity(PhaseGVN* phase); --- old/src/share/vm/opto/cfgnode.hpp 2016-07-03 23:42:52.322542324 +0900 +++ new/src/share/vm/opto/cfgnode.hpp 2016-07-03 23:42:52.182542906 +0900 @@ -85,7 +85,7 @@ PhiNode* has_unique_phi() const; // returns the unique phi user, or NULL // Is this region node unreachable from root? bool is_unreachable_region(PhaseGVN *phase) const; - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool pinned() const { return (const Node *)in(0) == this; } virtual bool is_CFG () const { return true; } virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash @@ -103,7 +103,7 @@ class JProjNode : public ProjNode { public: JProjNode( Node* ctrl, uint idx ) : ProjNode(ctrl,idx) {} - 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 const Node* is_block_proj() const { return in(0); } @@ -190,7 +190,7 @@ // Is it unsafe data loop? It becomes a dead loop if this phi node removed. bool is_unsafe_data_reference(Node *in) const; int is_diamond_phi(bool check_control_only = false) const; - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool pinned() const { return in(0) != 0; } virtual const TypePtr *adr_type() const { verify_adr_type(true); return _adr_type; } @@ -227,7 +227,7 @@ class GotoNode : public Node { public: GotoNode( Node *control ) : Node(control) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool pinned() const { return true; } virtual bool is_CFG() const { return true; } virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash @@ -248,7 +248,7 @@ class CProjNode : public ProjNode { public: CProjNode( Node *ctrl, uint idx ) : ProjNode(ctrl,idx) {} - 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 const Node *is_block_proj() const { return in(0); } @@ -373,7 +373,7 @@ init_req(0,control); init_req(1,b); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool pinned() const { return true; } virtual const Type *bottom_type() const { return TypeTuple::IFBOTH; } virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); @@ -404,7 +404,7 @@ init_class_id(Class_RangeCheck); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node* Ideal(PhaseGVN *phase, bool can_reshape); }; @@ -428,7 +428,7 @@ IfTrueNode( IfNode *ifnode ) : IfProjNode(ifnode,1) { init_class_id(Class_IfTrue); } - virtual int Opcode() const; + virtual uint Opcode() const; protected: virtual bool always_taken(const TypeTuple* t) const { return t == TypeTuple::IFTRUE; } @@ -439,7 +439,7 @@ IfFalseNode( IfNode *ifnode ) : IfProjNode(ifnode,0) { init_class_id(Class_IfFalse); } - virtual int Opcode() const; + virtual uint Opcode() const; protected: virtual bool always_taken(const TypeTuple* t) const { return t == TypeTuple::IFFALSE; } @@ -464,7 +464,7 @@ init_req(0, ctrl); init_req(1, idx); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *bottom_type() const; @@ -480,7 +480,7 @@ JumpNode( Node* control, Node* switch_val, uint size) : PCTableNode(control, switch_val, size) { init_class_id(Class_Jump); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const RegMask& out_RegMask() const; virtual const Node* is_block_proj() const { return this; } #ifndef PRODUCT @@ -503,7 +503,7 @@ init_class_id(Class_JumpProj); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return Type::CONTROL; } int dest_bci() const { return _dest_bci; } int switch_val() const { return _switch_val; } @@ -524,7 +524,7 @@ CatchNode( Node *ctrl, Node *idx, uint size ) : PCTableNode(ctrl,idx,size){ init_class_id(Class_Catch); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; }; @@ -552,7 +552,7 @@ assert(proj_no != fall_through_index || handler_bci < 0, "fall through case must have bci < 0"); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node* Identity(PhaseGVN* phase); virtual const Type *bottom_type() const { return Type::CONTROL; } int handler_bci() const { return _handler_bci; } @@ -571,7 +571,7 @@ init_req(0, control); init_req(1, i_o); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node* Identity(PhaseGVN* phase); virtual bool pinned() const { return true; } uint match_edge(uint idx) const { return 0; } @@ -585,7 +585,7 @@ class NeverBranchNode : public MultiBranchNode { public: NeverBranchNode( Node *ctrl ) : MultiBranchNode(1) { init_req(0,ctrl); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool pinned() const { return true; }; virtual const Type *bottom_type() const { return TypeTuple::IFBOTH; } virtual const Type* Value(PhaseGVN* phase) const; --- old/src/share/vm/opto/classes.cpp 2016-07-03 23:42:52.877540017 +0900 +++ new/src/share/vm/opto/classes.cpp 2016-07-03 23:42:52.740540587 +0900 @@ -51,7 +51,7 @@ // ---------------------------------------------------------------------------- // Build a table of virtual functions to map from Nodes to dense integer // opcode names. -int Node::Opcode() const { return Op_Node; } -#define macro(x) int x##Node::Opcode() const { return Op_##x; } +uint Node::Opcode() const { return Op_Node; } +#define macro(x) uint x##Node::Opcode() const { return Op_##x; } #include "classes.hpp" #undef macro --- old/src/share/vm/opto/compile.cpp 2016-07-03 23:42:53.408537810 +0900 +++ new/src/share/vm/opto/compile.cpp 2016-07-03 23:42:53.264538409 +0900 @@ -2870,7 +2870,7 @@ if (t->isa_oopptr() || t->isa_klassptr()) { Node* nn = NULL; - int op = t->isa_oopptr() ? Op_ConN : Op_ConNKlass; + uint op = t->isa_oopptr() ? Op_ConN : Op_ConNKlass; // Look for existing ConN node of the same exact type. Node* r = root(); --- old/src/share/vm/opto/connode.hpp 2016-07-03 23:42:54.078535026 +0900 +++ new/src/share/vm/opto/connode.hpp 2016-07-03 23:42:53.942535591 +0900 @@ -40,7 +40,7 @@ init_req(0, (Node*)Compile::current()->root()); init_flags(Flag_is_Con); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint hash() const; virtual const RegMask &out_RegMask() const { return RegMask::Empty; } virtual const RegMask &in_RegMask(uint) const { return RegMask::Empty; } @@ -54,7 +54,7 @@ class ConINode : public ConNode { public: ConINode( const TypeInt *t ) : ConNode(t) {} - virtual int Opcode() const; + virtual uint Opcode() const; // Factory method: static ConINode* make(int con) { @@ -68,7 +68,7 @@ class ConPNode : public ConNode { public: ConPNode( const TypePtr *t ) : ConNode(t) {} - virtual int Opcode() const; + virtual uint Opcode() const; // Factory methods: static ConPNode* make(address con) { @@ -85,7 +85,7 @@ class ConNNode : public ConNode { public: ConNNode( const TypeNarrowOop *t ) : ConNode(t) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------ConNKlassNode--------------------------------- @@ -93,7 +93,7 @@ class ConNKlassNode : public ConNode { public: ConNKlassNode( const TypeNarrowKlass *t ) : ConNode(t) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; @@ -102,7 +102,7 @@ class ConLNode : public ConNode { public: ConLNode( const TypeLong *t ) : ConNode(t) {} - virtual int Opcode() const; + virtual uint Opcode() const; // Factory method: static ConLNode* make(jlong con) { @@ -116,7 +116,7 @@ class ConFNode : public ConNode { public: ConFNode( const TypeF *t ) : ConNode(t) {} - virtual int Opcode() const; + virtual uint Opcode() const; // Factory method: static ConFNode* make(float con) { @@ -130,7 +130,7 @@ class ConDNode : public ConNode { public: ConDNode( const TypeD *t ) : ConNode(t) {} - virtual int Opcode() const; + virtual uint Opcode() const; // Factory method: static ConDNode* make(double con) { @@ -144,7 +144,7 @@ class ThreadLocalNode : public Node { public: ThreadLocalNode( ) : Node((Node*)Compile::current()->root()) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeRawPtr::BOTTOM;} virtual uint ideal_reg() const { return Op_RegP; } }; --- old/src/share/vm/opto/convertnode.hpp 2016-07-03 23:42:54.616532790 +0900 +++ new/src/share/vm/opto/convertnode.hpp 2016-07-03 23:42:54.479533359 +0900 @@ -34,7 +34,7 @@ class Conv2BNode : public Node { public: Conv2BNode( Node *i ) : Node(0,i) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::BOOL; } virtual Node* Identity(PhaseGVN* phase); virtual const Type* Value(PhaseGVN* phase) const; @@ -47,7 +47,7 @@ class ConvD2FNode : public Node { public: ConvD2FNode( Node *in1 ) : Node(0,in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::FLOAT; } virtual const Type* Value(PhaseGVN* phase) const; virtual Node* Identity(PhaseGVN* phase); @@ -59,7 +59,7 @@ class ConvD2INode : public Node { public: ConvD2INode( Node *in1 ) : Node(0,in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } virtual const Type* Value(PhaseGVN* phase) const; virtual Node* Identity(PhaseGVN* phase); @@ -72,7 +72,7 @@ class ConvD2LNode : public Node { public: ConvD2LNode( Node *dbl ) : Node(0,dbl) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeLong::LONG; } virtual const Type* Value(PhaseGVN* phase) const; virtual Node* Identity(PhaseGVN* phase); @@ -85,7 +85,7 @@ class ConvF2DNode : public Node { public: ConvF2DNode( Node *in1 ) : Node(0,in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::DOUBLE; } virtual const Type* Value(PhaseGVN* phase) const; virtual uint ideal_reg() const { return Op_RegD; } @@ -96,7 +96,7 @@ class ConvF2INode : public Node { public: ConvF2INode( Node *in1 ) : Node(0,in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } virtual const Type* Value(PhaseGVN* phase) const; virtual Node* Identity(PhaseGVN* phase); @@ -109,7 +109,7 @@ class ConvF2LNode : public Node { public: ConvF2LNode( Node *in1 ) : Node(0,in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeLong::LONG; } virtual const Type* Value(PhaseGVN* phase) const; virtual Node* Identity(PhaseGVN* phase); @@ -122,7 +122,7 @@ class ConvI2DNode : public Node { public: ConvI2DNode( Node *in1 ) : Node(0,in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::DOUBLE; } virtual const Type* Value(PhaseGVN* phase) const; virtual uint ideal_reg() const { return Op_RegD; } @@ -133,7 +133,7 @@ class ConvI2FNode : public Node { public: ConvI2FNode( Node *in1 ) : Node(0,in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::FLOAT; } virtual const Type* Value(PhaseGVN* phase) const; virtual Node* Identity(PhaseGVN* phase); @@ -147,7 +147,7 @@ ConvI2LNode(Node *in1, const TypeLong* t = TypeLong::INT) : TypeNode(t, 2) { init_req(1, in1); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual uint ideal_reg() const { return Op_RegL; } @@ -158,7 +158,7 @@ class ConvL2DNode : public Node { public: ConvL2DNode( Node *in1 ) : Node(0,in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::DOUBLE; } virtual const Type* Value(PhaseGVN* phase) const; virtual uint ideal_reg() const { return Op_RegD; } @@ -169,7 +169,7 @@ class ConvL2FNode : public Node { public: ConvL2FNode( Node *in1 ) : Node(0,in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::FLOAT; } virtual const Type* Value(PhaseGVN* phase) const; virtual uint ideal_reg() const { return Op_RegF; } @@ -180,7 +180,7 @@ class ConvL2INode : public Node { public: ConvL2INode( Node *in1 ) : Node(0,in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } virtual Node* Identity(PhaseGVN* phase); virtual const Type* Value(PhaseGVN* phase) const; @@ -192,7 +192,7 @@ class RoundFloatNode: public Node { public: RoundFloatNode(Node* c, Node *in1): Node(c, in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::FLOAT; } virtual uint ideal_reg() const { return Op_RegF; } virtual Node* Identity(PhaseGVN* phase); @@ -204,7 +204,7 @@ class RoundDoubleNode: public Node { public: RoundDoubleNode(Node* c, Node *in1): Node(c, in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::DOUBLE; } virtual uint ideal_reg() const { return Op_RegD; } virtual Node* Identity(PhaseGVN* phase); --- old/src/share/vm/opto/countbitsnode.hpp 2016-07-03 23:42:55.152530562 +0900 +++ new/src/share/vm/opto/countbitsnode.hpp 2016-07-03 23:42:55.014531135 +0900 @@ -43,7 +43,7 @@ class CountLeadingZerosINode : public CountBitsNode { public: CountLeadingZerosINode(Node* in1) : CountBitsNode(in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; }; @@ -52,7 +52,7 @@ class CountLeadingZerosLNode : public CountBitsNode { public: CountLeadingZerosLNode(Node* in1) : CountBitsNode(in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; }; @@ -61,7 +61,7 @@ class CountTrailingZerosINode : public CountBitsNode { public: CountTrailingZerosINode(Node* in1) : CountBitsNode(in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; }; @@ -70,7 +70,7 @@ class CountTrailingZerosLNode : public CountBitsNode { public: CountTrailingZerosLNode(Node* in1) : CountBitsNode(in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; }; @@ -79,7 +79,7 @@ class PopCountINode : public CountBitsNode { public: PopCountINode(Node* in1) : CountBitsNode(in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //---------- PopCountLNode ----------------------------------------------------- @@ -87,7 +87,7 @@ class PopCountLNode : public CountBitsNode { public: PopCountLNode(Node* in1) : CountBitsNode(in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; --- old/src/share/vm/opto/divnode.hpp 2016-07-03 23:42:55.687528338 +0900 +++ new/src/share/vm/opto/divnode.hpp 2016-07-03 23:42:55.549528912 +0900 @@ -43,7 +43,7 @@ class DivINode : public Node { public: DivINode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {} - 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; @@ -56,7 +56,7 @@ class DivLNode : public Node { public: DivLNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor ) {} - 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; @@ -69,7 +69,7 @@ class DivFNode : public Node { public: DivFNode( Node *c, Node *dividend, Node *divisor ) : Node(c, dividend, divisor) {} - 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; @@ -82,7 +82,7 @@ class DivDNode : public Node { public: DivDNode( Node *c, Node *dividend, Node *divisor ) : Node(c,dividend, divisor) {} - 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; @@ -95,7 +95,7 @@ class ModINode : public Node { public: ModINode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *bottom_type() const { return TypeInt::INT; } @@ -107,7 +107,7 @@ class ModLNode : public Node { public: ModLNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *bottom_type() const { return TypeLong::LONG; } @@ -119,7 +119,7 @@ class ModFNode : public Node { public: ModFNode( Node *c, Node *in1, Node *in2 ) : Node(c,in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual const Type *bottom_type() const { return Type::FLOAT; } virtual uint ideal_reg() const { return Op_RegF; } @@ -130,7 +130,7 @@ class ModDNode : public Node { public: ModDNode( Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual const Type *bottom_type() const { return Type::DOUBLE; } virtual uint ideal_reg() const { return Op_RegD; } @@ -146,7 +146,7 @@ div_proj_num = 0, // quotient mod_proj_num = 1 // remainder }; - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node* Identity(PhaseGVN* phase) { return this; } virtual Node *Ideal(PhaseGVN *phase, bool can_reshape) { return NULL; } virtual const Type* Value(PhaseGVN* phase) const { return bottom_type(); } @@ -163,7 +163,7 @@ class DivModINode : public DivModNode { public: DivModINode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeTuple::INT_PAIR; } virtual Node *match( const ProjNode *proj, const Matcher *m ); @@ -176,7 +176,7 @@ class DivModLNode : public DivModNode { public: DivModLNode( Node *c, Node *dividend, Node *divisor ) : DivModNode(c, dividend, divisor) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeTuple::LONG_PAIR; } virtual Node *match( const ProjNode *proj, const Matcher *m ); --- old/src/share/vm/opto/ifnode.cpp 2016-07-03 23:42:56.218526131 +0900 +++ new/src/share/vm/opto/ifnode.cpp 2016-07-03 23:42:56.079526709 +0900 @@ -1451,7 +1451,7 @@ igvn->hash_delete(this); // Remove self to prevent spurious V-N Node *idom = in(0); // Need opcode to decide which way 'this' test goes - int prev_op = prev_dom->Opcode(); + uint prev_op = prev_dom->Opcode(); Node *top = igvn->C->top(); // Shortcut to top // Loop predicates may have depending checks which should not @@ -1505,7 +1505,7 @@ // Setup to scan up the CFG looking for a dominating test Node* dom = in(0); Node* prev_dom = this; - int op = Opcode(); + uint op = Opcode(); // Search up the dominator tree for an If with an identical test while (dom->Opcode() != op || // Not same opcode? dom->in(1) != in(1) || // Not same input 1? --- old/src/share/vm/opto/intrinsicnode.hpp 2016-07-03 23:42:56.797523725 +0900 +++ new/src/share/vm/opto/intrinsicnode.hpp 2016-07-03 23:42:56.660524294 +0900 @@ -37,7 +37,7 @@ class PartialSubtypeCheckNode : public Node { public: PartialSubtypeCheckNode(Node* c, Node* sub, Node* super) : Node(c,sub,super) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeRawPtr::BOTTOM; } virtual uint ideal_reg() const { return Op_RegP; } }; @@ -87,7 +87,7 @@ StrCompNode(Node* control, Node* char_array_mem, Node* s1, Node* c1, Node* s2, Node* c2, ArgEncoding encoding): StrIntrinsicNode(control, char_array_mem, s1, c1, s2, c2, encoding) {}; - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeInt::INT; } }; @@ -97,7 +97,7 @@ StrEqualsNode(Node* control, Node* char_array_mem, Node* s1, Node* s2, Node* c, ArgEncoding encoding): StrIntrinsicNode(control, char_array_mem, s1, s2, c, encoding) {}; - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeInt::BOOL; } }; @@ -107,7 +107,7 @@ StrIndexOfNode(Node* control, Node* char_array_mem, Node* s1, Node* c1, Node* s2, Node* c2, ArgEncoding encoding): StrIntrinsicNode(control, char_array_mem, s1, c1, s2, c2, encoding) {}; - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeInt::INT; } }; @@ -117,7 +117,7 @@ StrIndexOfCharNode(Node* control, Node* char_array_mem, Node* s1, Node* c1, Node* c, ArgEncoding encoding): StrIntrinsicNode(control, char_array_mem, s1, c1, c, encoding) {}; - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeInt::INT; } }; @@ -127,7 +127,7 @@ StrCompressedCopyNode(Node* control, Node* arymem, Node* s1, Node* s2, Node* c): StrIntrinsicNode(control, arymem, s1, s2, c, none) {}; - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeInt::INT; } virtual const TypePtr* adr_type() const { return TypePtr::BOTTOM; } virtual Node* Ideal(PhaseGVN* phase, bool can_reshape); @@ -139,7 +139,7 @@ StrInflatedCopyNode(Node* control, Node* arymem, Node* s1, Node* s2, Node* c): StrIntrinsicNode(control, arymem, s1, s2, c, none) {}; - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return Type::MEMORY; } virtual const TypePtr* adr_type() const { return TypePtr::BOTTOM; } virtual Node* Ideal(PhaseGVN* phase, bool can_reshape); @@ -151,7 +151,7 @@ AryEqNode(Node* control, Node* char_array_mem, Node* s1, Node* s2, ArgEncoding encoding): StrIntrinsicNode(control, char_array_mem, s1, s2, encoding) {}; - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeInt::BOOL; } }; @@ -160,7 +160,7 @@ public: HasNegativesNode(Node* control, Node* char_array_mem, Node* s1, Node* c1): StrIntrinsicNode(control, char_array_mem, s1, c1, none) {}; - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeInt::BOOL; } }; @@ -170,7 +170,7 @@ class EncodeISOArrayNode: public Node { public: EncodeISOArrayNode(Node* control, Node* arymem, Node* s1, Node* s2, Node* c): Node(control, arymem, s1, s2, c) {}; - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool depends_only_on_test() const { return false; } virtual const Type* bottom_type() const { return TypeInt::INT; } virtual const TypePtr* adr_type() const { return TypePtr::BOTTOM; } --- old/src/share/vm/opto/library_call.cpp 2016-07-03 23:42:57.351521422 +0900 +++ new/src/share/vm/opto/library_call.cpp 2016-07-03 23:42:57.201522046 +0900 @@ -1974,7 +1974,7 @@ // It can simplify the index computation for Arrays.copyOf // and similar uses of System.arraycopy. // First, compute the normalized version of CmpI(x, y). - int cmp_op = Op_CmpI; + uint cmp_op = Op_CmpI; Node* xkey = xvalue; Node* ykey = yvalue; Node* ideal_cmpxy = _gvn.transform(new CmpINode(xkey, ykey)); --- old/src/share/vm/opto/locknode.hpp 2016-07-03 23:42:58.074518417 +0900 +++ new/src/share/vm/opto/locknode.hpp 2016-07-03 23:42:57.936518991 +0900 @@ -40,7 +40,7 @@ public: BoxLockNode( int lock ); - virtual int Opcode() const; + virtual uint Opcode() const; virtual void emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const; virtual uint size(PhaseRegAlloc *ra_) const; virtual const RegMask &in_RegMask(uint) const; @@ -95,7 +95,7 @@ virtual uint hash() const ; // { return NO_HASH; } virtual uint size_of() const; virtual uint cmp( const Node &n ) const ; // Always fail, except on self - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const { return TypeInt::CC; } const Type *sub(const Type *t1, const Type *t2) const { return TypeInt::CC;} @@ -122,7 +122,7 @@ // LockNode/UnLockNode to avoid creating Phi's. virtual uint hash() const ; // { return NO_HASH; } virtual uint cmp( const Node &n ) const ; // Always fail, except on self - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const { return TypeInt::CC; } const Type *sub(const Type *t1, const Type *t2) const { return TypeInt::CC;} --- old/src/share/vm/opto/loopnode.hpp 2016-07-03 23:42:58.604516215 +0900 +++ new/src/share/vm/opto/loopnode.hpp 2016-07-03 23:42:58.467516784 +0900 @@ -121,7 +121,7 @@ } virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); - virtual int Opcode() const; + virtual uint Opcode() const; bool can_be_counted_loop(PhaseTransform* phase) const { return req() == 3 && in(0) != NULL && in(1) != NULL && phase->type(in(1)) != Type::TOP && @@ -198,7 +198,7 @@ // Will be reset (lower) if the loop's trip count is known. } - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); Node *init_control() const { return in(EntryControl); } @@ -294,7 +294,7 @@ : IfNode( control, test, prob, cnt) { init_class_id(Class_CountedLoopEnd); } - virtual int Opcode() const; + virtual uint Opcode() const; Node *cmp_node() const { return (in(TestValue)->req() >=2) ? in(TestValue)->in(1) : NULL; } Node *incr() const { Node *tmp = cmp_node(); return (tmp && tmp->req()==3) ? tmp->in(1) : NULL; } @@ -366,7 +366,7 @@ init_flags(Flag_is_macro); C->add_macro_node(this); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } virtual const Type* Value(PhaseGVN* phase) const; --- old/src/share/vm/opto/machnode.hpp 2016-07-03 23:42:59.215513675 +0900 +++ new/src/share/vm/opto/machnode.hpp 2016-07-03 23:42:59.077514249 +0900 @@ -190,7 +190,7 @@ } // Required boilerplate virtual uint size_of() const { return sizeof(MachNode); } - virtual int Opcode() const; // Always equal to MachNode + virtual uint Opcode() const; // Always equal to MachNode virtual uint rule() const = 0; // Machine-specific opcode // Number of inputs which come before the first operand. // Generally at least 1, to skip the Control input @@ -708,7 +708,7 @@ unmatched_proj = 0, // Projs for Control, I/O, memory not matched fat_proj = 999 // Projs killing many regs, defined by _rout }; - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const; virtual const TypePtr *adr_type() const; virtual const RegMask &in_RegMask(uint) const { return RegMask::Empty; } --- old/src/share/vm/opto/matcher.cpp 2016-07-03 23:42:59.822511152 +0900 +++ new/src/share/vm/opto/matcher.cpp 2016-07-03 23:42:59.675511763 +0900 @@ -1927,7 +1927,7 @@ Node* _mop_node; int _con_op; - static int match_next(Node* n, int next_op, int next_op_idx) { + static int match_next(Node* n, uint next_op, int next_op_idx) { if (n->in(1) == NULL || n->in(2) == NULL) { return -1; } @@ -1950,8 +1950,8 @@ FusedPatternMatcher(Node* op1_node, Node *mop_node, int con_op) : _op1_node(op1_node), _mop_node(mop_node), _con_op(con_op) { } - bool match(int op1, int op1_op2_idx, // op1 and the index of the op1->op2 edge, -1 if op1 is commutative - int op2, int op2_con_idx, // op2 and the index of the op2->con edge, -1 if op2 is commutative + bool match(uint op1, int op1_op2_idx, // op1 and the index of the op1->op2 edge, -1 if op1 is commutative + uint op2, int op2_con_idx, // op2 and the index of the op2->con edge, -1 if op2 is commutative typename ConType::NativeType con_value) { if (_op1_node->Opcode() != op1) { return false; --- old/src/share/vm/opto/matcher.hpp 2016-07-03 23:43:00.446508559 +0900 +++ new/src/share/vm/opto/matcher.hpp 2016-07-03 23:43:00.306509141 +0900 @@ -299,7 +299,7 @@ RegMask *_calling_convention_mask; // Array of RegMasks per argument // Does matcher have a match rule for this ideal node? - static const bool has_match_rule(int opcode); + static const bool has_match_rule(uint opcode); static const bool _hasMatchRule[_last_opcode]; // Does matcher have a match rule for this ideal node and is the @@ -377,8 +377,8 @@ virtual OptoReg::Name return_addr() const; RegMask _return_addr_mask; // Return value register. On Intel it is EAX. On Sparc i0/o0. - static OptoRegPair return_value(int ideal_reg, bool is_outgoing); - static OptoRegPair c_return_value(int ideal_reg, bool is_outgoing); + static OptoRegPair return_value(uint ideal_reg, bool is_outgoing); + static OptoRegPair c_return_value(uint ideal_reg, bool is_outgoing); RegMask _return_value_mask; // Inline Cache Register static OptoReg::Name inline_cache_reg(); --- old/src/share/vm/opto/mathexactnode.hpp 2016-07-03 23:43:00.990506298 +0900 +++ new/src/share/vm/opto/mathexactnode.hpp 2016-07-03 23:43:00.854506863 +0900 @@ -72,7 +72,7 @@ typedef AddINode MathOp; OverflowAddINode(Node* in1, Node* in2) : OverflowINode(in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool will_overflow(jint v1, jint v2) const; virtual bool can_overflow(const Type* t1, const Type* t2) const; @@ -83,7 +83,7 @@ typedef SubINode MathOp; OverflowSubINode(Node* in1, Node* in2) : OverflowINode(in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool will_overflow(jint v1, jint v2) const; virtual bool can_overflow(const Type* t1, const Type* t2) const; @@ -94,7 +94,7 @@ typedef MulINode MathOp; OverflowMulINode(Node* in1, Node* in2) : OverflowINode(in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool will_overflow(jint v1, jint v2) const; virtual bool can_overflow(const Type* t1, const Type* t2) const; @@ -105,7 +105,7 @@ typedef AddLNode MathOp; OverflowAddLNode(Node* in1, Node* in2) : OverflowLNode(in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool will_overflow(jlong v1, jlong v2) const; virtual bool can_overflow(const Type* t1, const Type* t2) const; @@ -116,7 +116,7 @@ typedef SubLNode MathOp; OverflowSubLNode(Node* in1, Node* in2) : OverflowLNode(in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool will_overflow(jlong v1, jlong v2) const; virtual bool can_overflow(const Type* t1, const Type* t2) const; @@ -127,7 +127,7 @@ typedef MulLNode MathOp; OverflowMulLNode(Node* in1, Node* in2) : OverflowLNode(in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool will_overflow(jlong v1, jlong v2) const; virtual bool can_overflow(const Type* t1, const Type* t2) const; --- 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; } --- old/src/share/vm/opto/movenode.hpp 2016-07-03 23:43:02.152501468 +0900 +++ new/src/share/vm/opto/movenode.hpp 2016-07-03 23:43:02.015502038 +0900 @@ -56,7 +56,7 @@ class CMoveDNode : public CMoveNode { public: CMoveDNode( Node *bol, Node *left, Node *right, const Type* t) : CMoveNode(bol,left,right,t){} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); }; @@ -64,7 +64,7 @@ class CMoveFNode : public CMoveNode { public: CMoveFNode( Node *bol, Node *left, Node *right, const Type* t ) : CMoveNode(bol,left,right,t) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); }; @@ -72,7 +72,7 @@ class CMoveINode : public CMoveNode { public: CMoveINode( Node *bol, Node *left, Node *right, const TypeInt *ti ) : CMoveNode(bol,left,right,ti){} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); }; @@ -80,28 +80,28 @@ class CMoveLNode : public CMoveNode { public: CMoveLNode(Node *bol, Node *left, Node *right, const TypeLong *tl ) : CMoveNode(bol,left,right,tl){} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------CMovePNode------------------------------------- class CMovePNode : public CMoveNode { public: CMovePNode( Node *c, Node *bol, Node *left, Node *right, const TypePtr* t ) : CMoveNode(bol,left,right,t) { init_req(Control,c); } - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------CMoveNNode------------------------------------- class CMoveNNode : public CMoveNode { public: CMoveNNode( Node *c, Node *bol, Node *left, Node *right, const Type* t ) : CMoveNode(bol,left,right,t) { init_req(Control,c); } - virtual int Opcode() const; + virtual uint Opcode() const; }; // class MoveI2FNode : public Node { public: MoveI2FNode( Node *value ) : Node(0,value) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::FLOAT; } virtual uint ideal_reg() const { return Op_RegF; } virtual const Type* Value(PhaseGVN* phase) const; @@ -110,7 +110,7 @@ class MoveL2DNode : public Node { public: MoveL2DNode( Node *value ) : Node(0,value) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::DOUBLE; } virtual uint ideal_reg() const { return Op_RegD; } virtual const Type* Value(PhaseGVN* phase) const; @@ -119,7 +119,7 @@ class MoveF2INode : public Node { public: MoveF2INode( Node *value ) : Node(0,value) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } virtual const Type* Value(PhaseGVN* phase) const; @@ -128,7 +128,7 @@ class MoveD2LNode : public Node { public: MoveD2LNode( Node *value ) : Node(0,value) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeLong::LONG; } virtual uint ideal_reg() const { return Op_RegL; } virtual const Type* Value(PhaseGVN* phase) const; @@ -143,7 +143,7 @@ class BinaryNode : public Node { public: BinaryNode( Node *n1, Node *n2 ) : Node(0,n1,n2) { } - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return 0; } #ifndef PRODUCT --- old/src/share/vm/opto/mulnode.cpp 2016-07-03 23:43:02.681499270 +0900 +++ new/src/share/vm/opto/mulnode.cpp 2016-07-03 23:43:02.544499839 +0900 @@ -86,7 +86,7 @@ Node *mul1 = in(1); #ifdef ASSERT // Check for dead loop - int op1 = mul1->Opcode(); + uint op1 = mul1->Opcode(); if( phase->eqv( mul1, this ) || phase->eqv( in(2), this ) || ( op1 == mul_opcode() || op1 == add_opcode() ) && ( phase->eqv( mul1->in(1), this ) || phase->eqv( mul1->in(2), this ) || --- old/src/share/vm/opto/mulnode.hpp 2016-07-03 23:43:03.257496876 +0900 +++ new/src/share/vm/opto/mulnode.hpp 2016-07-03 23:43:03.118497453 +0900 @@ -70,10 +70,10 @@ virtual const Type *add_id() const = 0; // Supplied function to return the additive opcode - virtual int add_opcode() const = 0; + virtual uint add_opcode() const = 0; // Supplied function to return the multiplicative opcode - virtual int mul_opcode() const = 0; + virtual uint mul_opcode() const = 0; }; @@ -82,13 +82,13 @@ class MulINode : public MulNode { public: MulINode( Node *in1, Node *in2 ) : MulNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *mul_ring( const Type *, const Type * ) const; const Type *mul_id() const { return TypeInt::ONE; } const Type *add_id() const { return TypeInt::ZERO; } - int add_opcode() const { return Op_AddI; } - int mul_opcode() const { return Op_MulI; } + uint add_opcode() const { return Op_AddI; } + uint mul_opcode() const { return Op_MulI; } const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -98,13 +98,13 @@ class MulLNode : public MulNode { public: MulLNode( Node *in1, Node *in2 ) : MulNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *mul_ring( const Type *, const Type * ) const; const Type *mul_id() const { return TypeLong::ONE; } const Type *add_id() const { return TypeLong::ZERO; } - int add_opcode() const { return Op_AddL; } - int mul_opcode() const { return Op_MulL; } + uint add_opcode() const { return Op_AddL; } + uint mul_opcode() const { return Op_MulL; } const Type *bottom_type() const { return TypeLong::LONG; } virtual uint ideal_reg() const { return Op_RegL; } }; @@ -115,12 +115,12 @@ class MulFNode : public MulNode { public: MulFNode( Node *in1, Node *in2 ) : MulNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *mul_ring( const Type *, const Type * ) const; const Type *mul_id() const { return TypeF::ONE; } const Type *add_id() const { return TypeF::ZERO; } - int add_opcode() const { return Op_AddF; } - int mul_opcode() const { return Op_MulF; } + uint add_opcode() const { return Op_AddF; } + uint mul_opcode() const { return Op_MulF; } const Type *bottom_type() const { return Type::FLOAT; } virtual uint ideal_reg() const { return Op_RegF; } }; @@ -130,12 +130,12 @@ class MulDNode : public MulNode { public: MulDNode( Node *in1, Node *in2 ) : MulNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *mul_ring( const Type *, const Type * ) const; const Type *mul_id() const { return TypeD::ONE; } const Type *add_id() const { return TypeD::ZERO; } - int add_opcode() const { return Op_AddD; } - int mul_opcode() const { return Op_MulD; } + uint add_opcode() const { return Op_AddD; } + uint mul_opcode() const { return Op_MulD; } const Type *bottom_type() const { return Type::DOUBLE; } virtual uint ideal_reg() const { return Op_RegD; } }; @@ -145,7 +145,7 @@ class MulHiLNode : public Node { public: MulHiLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; const Type *bottom_type() const { return TypeLong::LONG; } virtual uint ideal_reg() const { return Op_RegL; } @@ -157,14 +157,14 @@ class AndINode : public MulINode { public: AndINode( Node *in1, Node *in2 ) : MulINode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual Node* Identity(PhaseGVN* phase); virtual const Type *mul_ring( const Type *, const Type * ) const; const Type *mul_id() const { return TypeInt::MINUS_1; } const Type *add_id() const { return TypeInt::ZERO; } - int add_opcode() const { return Op_OrI; } - int mul_opcode() const { return Op_AndI; } + uint add_opcode() const { return Op_OrI; } + uint mul_opcode() const { return Op_AndI; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -174,14 +174,14 @@ class AndLNode : public MulLNode { public: AndLNode( Node *in1, Node *in2 ) : MulLNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual Node* Identity(PhaseGVN* phase); virtual const Type *mul_ring( const Type *, const Type * ) const; const Type *mul_id() const { return TypeLong::MINUS_1; } const Type *add_id() const { return TypeLong::ZERO; } - int add_opcode() const { return Op_OrL; } - int mul_opcode() const { return Op_AndL; } + uint add_opcode() const { return Op_OrL; } + uint mul_opcode() const { return Op_AndL; } virtual uint ideal_reg() const { return Op_RegL; } }; @@ -190,7 +190,7 @@ class LShiftINode : public Node { public: LShiftINode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} - 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; @@ -203,7 +203,7 @@ class LShiftLNode : public Node { public: LShiftLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} - 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; @@ -216,7 +216,7 @@ class RShiftINode : public Node { public: RShiftINode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} - 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; @@ -229,7 +229,7 @@ class RShiftLNode : public Node { public: RShiftLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node* Identity(PhaseGVN* phase); virtual const Type* Value(PhaseGVN* phase) const; const Type *bottom_type() const { return TypeLong::LONG; } @@ -242,7 +242,7 @@ class URShiftINode : public Node { public: URShiftINode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} - 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; @@ -255,7 +255,7 @@ class URShiftLNode : public Node { public: URShiftLNode( Node *in1, Node *in2 ) : Node(0,in1,in2) {} - 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; --- old/src/share/vm/opto/multnode.hpp 2016-07-03 23:43:03.786494677 +0900 +++ new/src/share/vm/opto/multnode.hpp 2016-07-03 23:43:03.650495242 +0900 @@ -38,7 +38,7 @@ MultiNode( uint required ) : Node(required) { init_class_id(Class_Multi); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const = 0; virtual bool is_CFG() const { return true; } virtual uint hash() const { return NO_HASH; } // CFG nodes do not hash @@ -75,7 +75,7 @@ const uint _con; // The field in the tuple we are projecting const bool _is_io_use; // Used to distinguish between the projections // used on the control and io paths from a macro node - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool is_CFG() const; virtual bool depends_only_on_test() const { return false; } virtual const Type *bottom_type() const; --- old/src/share/vm/opto/narrowptrnode.hpp 2016-07-03 23:43:04.321492453 +0900 +++ new/src/share/vm/opto/narrowptrnode.hpp 2016-07-03 23:43:04.185493019 +0900 @@ -51,7 +51,7 @@ EncodeNarrowPtrNode(value, type) { init_class_id(Class_EncodeP); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node* Identity(PhaseGVN* phase); virtual const Type* Value(PhaseGVN* phase) const; }; @@ -66,7 +66,7 @@ EncodeNarrowPtrNode(value, type) { init_class_id(Class_EncodePKlass); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node* Identity(PhaseGVN* phase); virtual const Type* Value(PhaseGVN* phase) const; }; @@ -94,7 +94,7 @@ DecodeNarrowPtrNode(value, type) { init_class_id(Class_DecodeN); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual Node* Identity(PhaseGVN* phase); }; @@ -109,7 +109,7 @@ DecodeNarrowPtrNode(value, type) { init_class_id(Class_DecodeNKlass); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* Value(PhaseGVN* phase) const; virtual Node* Identity(PhaseGVN* phase); }; --- old/src/share/vm/opto/node.cpp 2016-07-03 23:43:04.847490267 +0900 +++ new/src/share/vm/opto/node.cpp 2016-07-03 23:43:04.708490845 +0900 @@ -905,7 +905,7 @@ } // Find out of current node that matches opcode. -Node* Node::find_out_with(int opcode) { +Node* Node::find_out_with(uint opcode) { for (DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++) { Node* use = fast_out(i); if (use->Opcode() == opcode) { @@ -916,14 +916,14 @@ } // Return true if the current node has an out that matches opcode. -bool Node::has_out_with(int opcode) { +bool Node::has_out_with(uint opcode) { return (find_out_with(opcode) != NULL); } // Return true if the current node has an out that matches any of the opcodes. -bool Node::has_out_with(int opcode1, int opcode2, int opcode3, int opcode4) { +bool Node::has_out_with(uint opcode1, uint opcode2, uint opcode3, uint opcode4) { for (DUIterator_Fast imax, i = fast_outs(imax); i < imax; i++) { - int opcode = fast_out(i)->Opcode(); + uint opcode = fast_out(i)->Opcode(); if (opcode == opcode1 || opcode == opcode2 || opcode == opcode3 || opcode == opcode4) { return true; } @@ -1131,7 +1131,7 @@ bool Node::has_special_unique_user() const { assert(outcnt() == 1, "match only for unique out"); Node* n = unique_out(); - int op = Opcode(); + uint op = Opcode(); if (this->is_Store()) { // Condition for back-to-back stores folding. return n->Opcode() == op && n->in(MemNode::Memory) == this; @@ -2290,7 +2290,7 @@ //--------------------------find_similar------------------------------ // Return a node with opcode "opc" and same inputs as "this" if one can // be found; Otherwise return NULL; -Node* Node::find_similar(int opc) { +Node* Node::find_similar(uint opc) { if (req() >= 2) { Node* def = in(1); if (def && def->outcnt() >= 2) { --- old/src/share/vm/opto/node.hpp 2016-07-03 23:43:05.447487774 +0900 +++ new/src/share/vm/opto/node.hpp 2016-07-03 23:43:05.308488351 +0900 @@ -458,11 +458,11 @@ } // Find out of current node that matches opcode. - Node* find_out_with(int opcode); + Node* find_out_with(uint opcode); // Return true if the current node has an out that matches opcode. - bool has_out_with(int opcode); + bool has_out_with(uint opcode); // Return true if the current node has an out that matches any of the opcodes. - bool has_out_with(int opcode1, int opcode2, int opcode3, int opcode4); + bool has_out_with(uint opcode1, uint opcode2, uint opcode3, uint opcode4); private: static Node* uncast_helper(const Node* n); @@ -757,7 +757,7 @@ void remove_flag(jushort fl) { clear_flag(fl); } // Return a dense integer opcode number - virtual int Opcode() const; + virtual uint Opcode() const; // Virtual inherited Node size virtual uint size_of() const; @@ -992,7 +992,7 @@ // Return a node with opcode "opc" and same inputs as "this" if one can // be found; Otherwise return NULL; - Node* find_similar(int opc); + Node* find_similar(uint opc); // Return the unique control out if only one. Null if none or more than one. Node* unique_ctrl_out() const; --- old/src/share/vm/opto/opaquenode.hpp 2016-07-03 23:43:06.020485392 +0900 +++ new/src/share/vm/opto/opaquenode.hpp 2016-07-03 23:43:05.885485953 +0900 @@ -48,7 +48,7 @@ C->add_macro_node(this); } Node* original_loop_limit() { return req()==3 ? in(2) : NULL; } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } virtual Node* Identity(PhaseGVN* phase); }; @@ -71,7 +71,7 @@ init_flags(Flag_is_macro); C->add_macro_node(this); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } }; @@ -83,7 +83,7 @@ public: enum { RTM_OPT }; Opaque3Node(Compile* C, Node *n, int opt) : Opaque2Node(C, n), _opt(opt) {} - virtual int Opcode() const; + virtual uint Opcode() const; bool rtm_opt() const { return (_opt == RTM_OPT); } }; @@ -107,7 +107,7 @@ void consume() { _consumed = true; } - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual Node* Identity(PhaseGVN* phase); virtual const Type *bottom_type() const { return TypeInt::BOOL; } --- old/src/share/vm/opto/opcodes.hpp 2016-07-03 23:43:06.549483193 +0900 +++ new/src/share/vm/opto/opcodes.hpp 2016-07-03 23:43:06.412483763 +0900 @@ -27,7 +27,7 @@ // Build a big enum of class names to give them dense integer indices #define macro(x) Op_##x, -enum Opcodes { +enum Opcodes : uint { Op_Node = 0, macro(Set) // Instruction selection match rule macro(RegN) // Machine narrow oop register --- old/src/share/vm/opto/phaseX.cpp 2016-07-03 23:43:07.079480991 +0900 +++ new/src/share/vm/opto/phaseX.cpp 2016-07-03 23:43:06.941481564 +0900 @@ -108,7 +108,7 @@ return NULL; // Miss! } - int op = n->Opcode(); + uint op = n->Opcode(); uint req = n->req(); while( 1 ) { // While probing hash table if( k->req() == req && // Same count of inputs @@ -160,7 +160,7 @@ first_sentinel = key; // Can insert here } - int op = n->Opcode(); + uint op = n->Opcode(); uint req = n->req(); while( 1 ) { // While probing hash table if( k->req() == req && // Same count of inputs --- old/src/share/vm/opto/rootnode.hpp 2016-07-03 23:43:07.668478543 +0900 +++ new/src/share/vm/opto/rootnode.hpp 2016-07-03 23:43:07.530479116 +0900 @@ -39,7 +39,7 @@ del_req(2); del_req(1); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Node *is_block_proj() const { return this; } virtual const Type *bottom_type() const { return Type::BOTTOM; } virtual Node* Identity(PhaseGVN* phase) { return this; } @@ -52,7 +52,7 @@ class HaltNode : public Node { public: HaltNode( Node *ctrl, Node *frameptr ); - virtual int Opcode() const; + virtual uint Opcode() const; virtual bool pinned() const { return true; }; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type* Value(PhaseGVN* phase) const; --- old/src/share/vm/opto/subnode.hpp 2016-07-03 23:43:08.204476315 +0900 +++ new/src/share/vm/opto/subnode.hpp 2016-07-03 23:43:08.062476905 +0900 @@ -69,7 +69,7 @@ class SubINode : public SubNode { public: SubINode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *sub( const Type *, const Type * ) const; const Type *add_id() const { return TypeInt::ZERO; } @@ -82,7 +82,7 @@ class SubLNode : public SubNode { public: SubLNode( Node *in1, Node *in2 ) : SubNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *sub( const Type *, const Type * ) const; const Type *add_id() const { return TypeLong::ZERO; } @@ -106,7 +106,7 @@ class SubFNode : public SubFPNode { public: SubFNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *sub( const Type *, const Type * ) const; const Type *add_id() const { return TypeF::ZERO; } @@ -120,7 +120,7 @@ class SubDNode : public SubFPNode { public: SubDNode( Node *in1, Node *in2 ) : SubFPNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *sub( const Type *, const Type * ) const; const Type *add_id() const { return TypeD::ZERO; } @@ -153,7 +153,7 @@ class CmpINode : public CmpNode { public: CmpINode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *sub( const Type *, const Type * ) const; }; @@ -163,7 +163,7 @@ class CmpUNode : public CmpNode { public: CmpUNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *sub( const Type *, const Type * ) const; const Type* Value(PhaseGVN* phase) const; bool is_index_range_check() const; @@ -174,7 +174,7 @@ class CmpPNode : public CmpNode { public: CmpPNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *sub( const Type *, const Type * ) const; }; @@ -184,7 +184,7 @@ class CmpNNode : public CmpNode { public: CmpNNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type *sub( const Type *, const Type * ) const; }; @@ -194,7 +194,7 @@ class CmpLNode : public CmpNode { public: CmpLNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *sub( const Type *, const Type * ) const; }; @@ -206,7 +206,7 @@ // Since it is not consumed by Bools, it is not really a Cmp. init_class_id(Class_Sub); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegI; } }; @@ -217,7 +217,7 @@ class CmpFNode : public CmpNode { public: CmpFNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; } const Type* Value(PhaseGVN* phase) const; }; @@ -232,7 +232,7 @@ // Since it is not consumed by Bools, it is not really a Cmp. init_class_id(Class_Sub); } - virtual int Opcode() const; + virtual uint Opcode() const; // Since it is not consumed by Bools, it is not really a Cmp. virtual uint ideal_reg() const { return Op_RegI; } }; @@ -245,7 +245,7 @@ class CmpDNode : public CmpNode { public: CmpDNode( Node *in1, Node *in2 ) : CmpNode(in1,in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *sub( const Type *, const Type * ) const { ShouldNotReachHere(); return NULL; } const Type* Value(PhaseGVN* phase) const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); @@ -261,7 +261,7 @@ // Since it is not consumed by Bools, it is not really a Cmp. init_class_id(Class_Sub); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Op_RegI; } }; @@ -307,7 +307,7 @@ Node* as_int_value(PhaseGVN* phase); // Invert sense of self, returning new Bool. BoolNode* negate(PhaseGVN* phase); - virtual int Opcode() const; + virtual uint Opcode() const; virtual Node *Ideal(PhaseGVN *phase, bool can_reshape); virtual const Type* Value(PhaseGVN* phase) const; virtual const Type *bottom_type() const { return TypeInt::BOOL; } @@ -335,7 +335,7 @@ class AbsINode : public AbsNode { public: AbsINode( Node *in1 ) : AbsNode(in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -347,7 +347,7 @@ class AbsFNode : public AbsNode { public: AbsFNode( Node *in1 ) : AbsNode(in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return Type::FLOAT; } virtual uint ideal_reg() const { return Op_RegF; } }; @@ -359,7 +359,7 @@ class AbsDNode : public AbsNode { public: AbsDNode( Node *in1 ) : AbsNode(in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return Type::DOUBLE; } virtual uint ideal_reg() const { return Op_RegD; } }; @@ -370,7 +370,7 @@ class CmpLTMaskNode : public Node { public: CmpLTMaskNode( Node *p, Node *q ) : Node(0, p, q) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -390,7 +390,7 @@ class NegFNode : public NegNode { public: NegFNode( Node *in1 ) : NegNode(in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return Type::FLOAT; } virtual uint ideal_reg() const { return Op_RegF; } }; @@ -403,7 +403,7 @@ class NegDNode : public NegNode { public: NegDNode( Node *in1 ) : NegNode(in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return Type::DOUBLE; } virtual uint ideal_reg() const { return Op_RegD; } }; @@ -413,7 +413,7 @@ class AtanDNode : public Node { public: AtanDNode(Node *c, Node *in1, Node *in2 ) : Node(c, in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return Type::DOUBLE; } virtual uint ideal_reg() const { return Op_RegD; } }; @@ -427,7 +427,7 @@ init_flags(Flag_is_expensive); C->add_expensive_node(this); } - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return Type::DOUBLE; } virtual uint ideal_reg() const { return Op_RegD; } virtual const Type* Value(PhaseGVN* phase) const; @@ -438,7 +438,7 @@ class ReverseBytesINode : public Node { public: ReverseBytesINode(Node *c, Node *in1) : Node(c, in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -448,7 +448,7 @@ class ReverseBytesLNode : public Node { public: ReverseBytesLNode(Node *c, Node *in1) : Node(c, in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return TypeLong::LONG; } virtual uint ideal_reg() const { return Op_RegL; } }; @@ -458,7 +458,7 @@ class ReverseBytesUSNode : public Node { public: ReverseBytesUSNode(Node *c, Node *in1) : Node(c, in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return TypeInt::CHAR; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -468,7 +468,7 @@ class ReverseBytesSNode : public Node { public: ReverseBytesSNode(Node *c, Node *in1) : Node(c, in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return TypeInt::SHORT; } virtual uint ideal_reg() const { return Op_RegI; } }; --- old/src/share/vm/opto/type.hpp 2016-07-03 23:43:08.798473846 +0900 +++ new/src/share/vm/opto/type.hpp 2016-07-03 23:43:08.657474432 +0900 @@ -135,7 +135,7 @@ const BasicType basic_type; const char* msg; const bool isa_oop; - const int ideal_reg; + const uint ideal_reg; const relocInfo::relocType reloc; } TypeInfo; --- old/src/share/vm/opto/vectornode.hpp 2016-07-03 23:43:09.415471282 +0900 +++ new/src/share/vm/opto/vectornode.hpp 2016-07-03 23:43:09.279471847 +0900 @@ -55,7 +55,7 @@ uint length() const { return vect_type()->length(); } // Vector length uint length_in_bytes() const { return vect_type()->length_in_bytes(); } - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(vect_type()->length_in_bytes()); } @@ -78,7 +78,7 @@ class AddVBNode : public VectorNode { public: AddVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------AddVSNode-------------------------------------- @@ -86,7 +86,7 @@ class AddVSNode : public VectorNode { public: AddVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------AddVINode-------------------------------------- @@ -94,7 +94,7 @@ class AddVINode : public VectorNode { public: AddVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------AddVLNode-------------------------------------- @@ -102,7 +102,7 @@ class AddVLNode : public VectorNode { public: AddVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------AddVFNode-------------------------------------- @@ -110,7 +110,7 @@ class AddVFNode : public VectorNode { public: AddVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------AddVDNode-------------------------------------- @@ -118,7 +118,7 @@ class AddVDNode : public VectorNode { public: AddVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------ReductionNode------------------------------------ @@ -137,7 +137,7 @@ class AddReductionVINode : public ReductionNode { public: AddReductionVINode(Node * ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -147,7 +147,7 @@ class AddReductionVLNode : public ReductionNode { public: AddReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeLong::LONG; } virtual uint ideal_reg() const { return Op_RegL; } }; @@ -157,7 +157,7 @@ class AddReductionVFNode : public ReductionNode { public: AddReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return Type::FLOAT; } virtual uint ideal_reg() const { return Op_RegF; } }; @@ -167,7 +167,7 @@ class AddReductionVDNode : public ReductionNode { public: AddReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return Type::DOUBLE; } virtual uint ideal_reg() const { return Op_RegD; } }; @@ -177,7 +177,7 @@ class SubVBNode : public VectorNode { public: SubVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------SubVSNode-------------------------------------- @@ -185,7 +185,7 @@ class SubVSNode : public VectorNode { public: SubVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------SubVINode-------------------------------------- @@ -193,7 +193,7 @@ class SubVINode : public VectorNode { public: SubVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------SubVLNode-------------------------------------- @@ -201,7 +201,7 @@ class SubVLNode : public VectorNode { public: SubVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------SubVFNode-------------------------------------- @@ -209,7 +209,7 @@ class SubVFNode : public VectorNode { public: SubVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------SubVDNode-------------------------------------- @@ -217,7 +217,7 @@ class SubVDNode : public VectorNode { public: SubVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------MulVSNode-------------------------------------- @@ -225,7 +225,7 @@ class MulVSNode : public VectorNode { public: MulVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------MulVINode-------------------------------------- @@ -233,7 +233,7 @@ class MulVINode : public VectorNode { public: MulVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------MulVLNode-------------------------------------- @@ -241,7 +241,7 @@ class MulVLNode : public VectorNode { public: MulVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------MulVFNode-------------------------------------- @@ -249,7 +249,7 @@ class MulVFNode : public VectorNode { public: MulVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------MulVDNode-------------------------------------- @@ -257,7 +257,7 @@ class MulVDNode : public VectorNode { public: MulVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------CMoveVDNode-------------------------------------- @@ -265,7 +265,7 @@ class CMoveVDNode : public VectorNode { public: CMoveVDNode(Node* in1, Node* in2, Node* in3, const TypeVect* vt) : VectorNode(in1, in2, in3, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------MulReductionVINode-------------------------------------- @@ -273,7 +273,7 @@ class MulReductionVINode : public ReductionNode { public: MulReductionVINode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -283,7 +283,7 @@ class MulReductionVLNode : public ReductionNode { public: MulReductionVLNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return TypeLong::LONG; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -293,7 +293,7 @@ class MulReductionVFNode : public ReductionNode { public: MulReductionVFNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return Type::FLOAT; } virtual uint ideal_reg() const { return Op_RegF; } }; @@ -303,7 +303,7 @@ class MulReductionVDNode : public ReductionNode { public: MulReductionVDNode(Node *ctrl, Node* in1, Node* in2) : ReductionNode(ctrl, in1, in2) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type* bottom_type() const { return Type::DOUBLE; } virtual uint ideal_reg() const { return Op_RegD; } }; @@ -313,7 +313,7 @@ class DivVFNode : public VectorNode { public: DivVFNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------DivVDNode-------------------------------------- @@ -321,7 +321,7 @@ class DivVDNode : public VectorNode { public: DivVDNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------AbsVFNode-------------------------------------- @@ -329,7 +329,7 @@ class AbsVFNode : public VectorNode { public: AbsVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------AbsVDNode-------------------------------------- @@ -337,7 +337,7 @@ class AbsVDNode : public VectorNode { public: AbsVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------NegVFNode-------------------------------------- @@ -345,7 +345,7 @@ class NegVFNode : public VectorNode { public: NegVFNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------NegVDNode-------------------------------------- @@ -353,7 +353,7 @@ class NegVDNode : public VectorNode { public: NegVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------SqrtVDNode-------------------------------------- @@ -361,7 +361,7 @@ class SqrtVDNode : public VectorNode { public: SqrtVDNode(Node* in, const TypeVect* vt) : VectorNode(in,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------LShiftVBNode----------------------------------- @@ -369,7 +369,7 @@ class LShiftVBNode : public VectorNode { public: LShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------LShiftVSNode----------------------------------- @@ -377,7 +377,7 @@ class LShiftVSNode : public VectorNode { public: LShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------LShiftVINode----------------------------------- @@ -385,7 +385,7 @@ class LShiftVINode : public VectorNode { public: LShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------LShiftVLNode----------------------------------- @@ -393,7 +393,7 @@ class LShiftVLNode : public VectorNode { public: LShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------RShiftVBNode----------------------------------- @@ -401,7 +401,7 @@ class RShiftVBNode : public VectorNode { public: RShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------RShiftVSNode----------------------------------- @@ -409,7 +409,7 @@ class RShiftVSNode : public VectorNode { public: RShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------RShiftVINode----------------------------------- @@ -417,7 +417,7 @@ class RShiftVINode : public VectorNode { public: RShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------RShiftVLNode----------------------------------- @@ -425,7 +425,7 @@ class RShiftVLNode : public VectorNode { public: RShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------URShiftVBNode---------------------------------- @@ -433,7 +433,7 @@ class URShiftVBNode : public VectorNode { public: URShiftVBNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------URShiftVSNode---------------------------------- @@ -441,7 +441,7 @@ class URShiftVSNode : public VectorNode { public: URShiftVSNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------URShiftVINode---------------------------------- @@ -449,7 +449,7 @@ class URShiftVINode : public VectorNode { public: URShiftVINode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------URShiftVLNode---------------------------------- @@ -457,7 +457,7 @@ class URShiftVLNode : public VectorNode { public: URShiftVLNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------LShiftCntVNode--------------------------------- @@ -465,7 +465,7 @@ class LShiftCntVNode : public VectorNode { public: LShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); } }; @@ -474,7 +474,7 @@ class RShiftCntVNode : public VectorNode { public: RShiftCntVNode(Node* cnt, const TypeVect* vt) : VectorNode(cnt,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Matcher::vector_shift_count_ideal_reg(vect_type()->length_in_bytes()); } }; @@ -484,7 +484,7 @@ class AndVNode : public VectorNode { public: AndVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------OrVNode--------------------------------------- @@ -492,7 +492,7 @@ class OrVNode : public VectorNode { public: OrVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------XorVNode--------------------------------------- @@ -500,7 +500,7 @@ class XorVNode : public VectorNode { public: XorVNode(Node* in1, Node* in2, const TypeVect* vt) : VectorNode(in1,in2,vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //================================= M E M O R Y =============================== @@ -517,13 +517,13 @@ const TypeVect* vect_type() const { return type()->is_vect(); } uint length() const { return vect_type()->length(); } // Vector length - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); } virtual BasicType memory_type() const { return T_VOID; } virtual int memory_size() const { return vect_type()->length_in_bytes(); } - virtual int store_Opcode() const { return Op_StoreVector; } + virtual uint store_Opcode() const { return Op_StoreVector; } static LoadVectorNode* make(int opc, Node* ctl, Node* mem, Node* adr, const TypePtr* atyp, @@ -545,7 +545,7 @@ const TypeVect* vect_type() const { return in(MemNode::ValueIn)->bottom_type()->is_vect(); } uint length() const { return vect_type()->length(); } // Vector length - virtual int Opcode() const; + virtual uint Opcode() const; virtual uint ideal_reg() const { return Matcher::vector_ideal_reg(memory_size()); } virtual BasicType memory_type() const { return T_VOID; } @@ -566,7 +566,7 @@ class ReplicateBNode : public VectorNode { public: ReplicateBNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------ReplicateSNode--------------------------------- @@ -574,7 +574,7 @@ class ReplicateSNode : public VectorNode { public: ReplicateSNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------ReplicateINode--------------------------------- @@ -582,7 +582,7 @@ class ReplicateINode : public VectorNode { public: ReplicateINode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------ReplicateLNode--------------------------------- @@ -590,7 +590,7 @@ class ReplicateLNode : public VectorNode { public: ReplicateLNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------ReplicateFNode--------------------------------- @@ -598,7 +598,7 @@ class ReplicateFNode : public VectorNode { public: ReplicateFNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------ReplicateDNode--------------------------------- @@ -606,7 +606,7 @@ class ReplicateDNode : public VectorNode { public: ReplicateDNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //========================Pack_Scalars_into_a_Vector=========================== @@ -617,7 +617,7 @@ public: PackNode(Node* in1, const TypeVect* vt) : VectorNode(in1, vt) {} PackNode(Node* in1, Node* n2, const TypeVect* vt) : VectorNode(in1, n2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; void add_opd(Node* n) { add_req(n); @@ -634,7 +634,7 @@ class PackBNode : public PackNode { public: PackBNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------PackSNode-------------------------------------- @@ -643,7 +643,7 @@ public: PackSNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} PackSNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------PackINode-------------------------------------- @@ -652,7 +652,7 @@ public: PackINode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} PackINode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------PackLNode-------------------------------------- @@ -661,7 +661,7 @@ public: PackLNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} PackLNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------Pack2LNode------------------------------------- @@ -669,7 +669,7 @@ class Pack2LNode : public PackNode { public: Pack2LNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------PackFNode-------------------------------------- @@ -678,7 +678,7 @@ public: PackFNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} PackFNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------PackDNode-------------------------------------- @@ -687,7 +687,7 @@ public: PackDNode(Node* in1, const TypeVect* vt) : PackNode(in1, vt) {} PackDNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; //------------------------------Pack2DNode------------------------------------- @@ -695,7 +695,7 @@ class Pack2DNode : public PackNode { public: Pack2DNode(Node* in1, Node* in2, const TypeVect* vt) : PackNode(in1, in2, vt) {} - virtual int Opcode() const; + virtual uint Opcode() const; }; @@ -708,7 +708,7 @@ ExtractNode(Node* src, ConINode* pos) : Node(NULL, src, (Node*)pos) { assert(in(2)->get_int() >= 0, "positive constants"); } - virtual int Opcode() const; + virtual uint Opcode() const; uint pos() const { return in(2)->get_int(); } static Node* make(Node* v, uint position, BasicType bt); @@ -719,7 +719,7 @@ class ExtractBNode : public ExtractNode { public: ExtractBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -729,7 +729,7 @@ class ExtractUBNode : public ExtractNode { public: ExtractUBNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -739,7 +739,7 @@ class ExtractCNode : public ExtractNode { public: ExtractCNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -749,7 +749,7 @@ class ExtractSNode : public ExtractNode { public: ExtractSNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -759,7 +759,7 @@ class ExtractINode : public ExtractNode { public: ExtractINode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } }; @@ -769,7 +769,7 @@ class ExtractLNode : public ExtractNode { public: ExtractLNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return TypeLong::LONG; } virtual uint ideal_reg() const { return Op_RegL; } }; @@ -779,7 +779,7 @@ class ExtractFNode : public ExtractNode { public: ExtractFNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::FLOAT; } virtual uint ideal_reg() const { return Op_RegF; } }; @@ -789,7 +789,7 @@ class ExtractDNode : public ExtractNode { public: ExtractDNode(Node* src, ConINode* pos) : ExtractNode(src, pos) {} - virtual int Opcode() const; + virtual uint Opcode() const; virtual const Type *bottom_type() const { return Type::DOUBLE; } virtual uint ideal_reg() const { return Op_RegD; } }; @@ -799,7 +799,7 @@ class SetVectMaskINode : public Node { public: SetVectMaskINode(Node *c, Node *in1) : Node(c, in1) {} - virtual int Opcode() const; + virtual uint Opcode() const; const Type *bottom_type() const { return TypeInt::INT; } virtual uint ideal_reg() const { return Op_RegI; } virtual const Type *Value(PhaseGVN *phase) const { return TypeInt::INT; }