54 class CatchNode;
55 class CatchProjNode;
56 class CheckCastPPNode;
57 class CastIINode;
58 class ClearArrayNode;
59 class CmpNode;
60 class CodeBuffer;
61 class ConstraintCastNode;
62 class ConNode;
63 class CountedLoopNode;
64 class CountedLoopEndNode;
65 class DecodeNarrowPtrNode;
66 class DecodeNNode;
67 class DecodeNKlassNode;
68 class EncodeNarrowPtrNode;
69 class EncodePNode;
70 class EncodePKlassNode;
71 class FastLockNode;
72 class FastUnlockNode;
73 class IfNode;
74 class IfFalseNode;
75 class IfTrueNode;
76 class InitializeNode;
77 class JVMState;
78 class JumpNode;
79 class JumpProjNode;
80 class LoadNode;
81 class LoadStoreNode;
82 class LockNode;
83 class LoopNode;
84 class MachBranchNode;
85 class MachCallDynamicJavaNode;
86 class MachCallJavaNode;
87 class MachCallLeafNode;
88 class MachCallNode;
89 class MachCallRuntimeNode;
90 class MachCallStaticJavaNode;
91 class MachConstantBaseNode;
92 class MachConstantNode;
93 class MachGotoNode;
94 class MachIfNode;
95 class MachNode;
96 class MachNullCheckNode;
97 class MachProjNode;
98 class MachReturnNode;
99 class MachSafePointNode;
100 class MachSpillCopyNode;
101 class MachTempNode;
102 class MachMergeNode;
103 class Matcher;
104 class MemBarNode;
105 class MemBarStoreStoreNode;
106 class MemNode;
107 class MergeMemNode;
108 class MulNode;
109 class MultiNode;
110 class MultiBranchNode;
111 class NeverBranchNode;
112 class Node;
113 class Node_Array;
114 class Node_List;
115 class Node_Stack;
116 class NullCheckNode;
117 class OopMap;
118 class ParmNode;
119 class PCTableNode;
120 class PhaseCCP;
121 class PhaseGVN;
122 class PhaseIterGVN;
123 class PhaseRegAlloc;
124 class PhaseTransform;
125 class PhaseValues;
126 class PhiNode;
127 class Pipeline;
128 class ProjNode;
129 class RegMask;
130 class RegionNode;
131 class RootNode;
132 class SafePointNode;
133 class SafePointScalarObjectNode;
134 class StartNode;
135 class State;
136 class StoreNode;
137 class SubNode;
138 class Type;
139 class TypeNode;
140 class UnlockNode;
141 class VectorNode;
142 class LoadVectorNode;
143 class StoreVectorNode;
144 class VectorSet;
145 typedef void (*NFunc)(Node&,void*);
146 extern "C" {
147 typedef int (*C_sort_func_t)(const void *, const void *);
148 }
149
150 // The type of all node counts and indexes.
151 // It must hold at least 16 bits, but must also be fast to load and store.
152 // This type, if less than 32 bits, could limit the number of possible nodes.
153 // (To make this type platform-specific, move to globalDefinitions_xxx.hpp.)
436 int replace_edge(Node* old, Node* neww);
437 int replace_edges_in_range(Node* old, Node* neww, int start, int end);
438 // NULL out all inputs to eliminate incoming Def-Use edges.
439 // Return the number of edges between 'n' and 'this'
440 int disconnect_inputs(Node *n, Compile *c);
441
442 // Quickly, return true if and only if I am Compile::current()->top().
443 bool is_top() const {
444 assert((this == (Node*) Compile::current()->top()) == (_out == NULL), "");
445 return (_out == NULL);
446 }
447 // Reaffirm invariants for is_top. (Only from Compile::set_cached_top_node.)
448 void setup_is_top();
449
450 // Strip away casting. (It is depth-limited.)
451 Node* uncast() const;
452 // Return whether two Nodes are equivalent, after stripping casting.
453 bool eqv_uncast(const Node* n) const {
454 return (this->uncast() == n->uncast());
455 }
456
457 // Find out of current node that matches opcode.
458 Node* find_out_with(int opcode);
459
460 private:
461 static Node* uncast_helper(const Node* n);
462
463 // Add an output edge to the end of the list
464 void add_out( Node *n ) {
465 if (is_top()) return;
466 if( _outcnt == _outmax ) out_grow(_outcnt);
467 _out[_outcnt++] = n;
468 }
469 // Delete an output edge
470 void del_out( Node *n ) {
471 if (is_top()) return;
472 Node** outp = &_out[_outcnt];
473 // Find and remove n
474 do {
475 assert(outp > _out, "Missing Def-Use edge");
619 DEFINE_CLASS_ID(MemBarStoreStore, MemBar, 1)
620
621 DEFINE_CLASS_ID(Mach, Node, 1)
622 DEFINE_CLASS_ID(MachReturn, Mach, 0)
623 DEFINE_CLASS_ID(MachSafePoint, MachReturn, 0)
624 DEFINE_CLASS_ID(MachCall, MachSafePoint, 0)
625 DEFINE_CLASS_ID(MachCallJava, MachCall, 0)
626 DEFINE_CLASS_ID(MachCallStaticJava, MachCallJava, 0)
627 DEFINE_CLASS_ID(MachCallDynamicJava, MachCallJava, 1)
628 DEFINE_CLASS_ID(MachCallRuntime, MachCall, 1)
629 DEFINE_CLASS_ID(MachCallLeaf, MachCallRuntime, 0)
630 DEFINE_CLASS_ID(MachBranch, Mach, 1)
631 DEFINE_CLASS_ID(MachIf, MachBranch, 0)
632 DEFINE_CLASS_ID(MachGoto, MachBranch, 1)
633 DEFINE_CLASS_ID(MachNullCheck, MachBranch, 2)
634 DEFINE_CLASS_ID(MachSpillCopy, Mach, 2)
635 DEFINE_CLASS_ID(MachTemp, Mach, 3)
636 DEFINE_CLASS_ID(MachConstantBase, Mach, 4)
637 DEFINE_CLASS_ID(MachConstant, Mach, 5)
638 DEFINE_CLASS_ID(MachMerge, Mach, 6)
639
640 DEFINE_CLASS_ID(Type, Node, 2)
641 DEFINE_CLASS_ID(Phi, Type, 0)
642 DEFINE_CLASS_ID(ConstraintCast, Type, 1)
643 DEFINE_CLASS_ID(CastII, ConstraintCast, 0)
644 DEFINE_CLASS_ID(CheckCastPP, Type, 2)
645 DEFINE_CLASS_ID(CMove, Type, 3)
646 DEFINE_CLASS_ID(SafePointScalarObject, Type, 4)
647 DEFINE_CLASS_ID(DecodeNarrowPtr, Type, 5)
648 DEFINE_CLASS_ID(DecodeN, DecodeNarrowPtr, 0)
649 DEFINE_CLASS_ID(DecodeNKlass, DecodeNarrowPtr, 1)
650 DEFINE_CLASS_ID(EncodeNarrowPtr, Type, 6)
651 DEFINE_CLASS_ID(EncodeP, EncodeNarrowPtr, 0)
652 DEFINE_CLASS_ID(EncodePKlass, EncodeNarrowPtr, 1)
653
654 DEFINE_CLASS_ID(Proj, Node, 3)
655 DEFINE_CLASS_ID(CatchProj, Proj, 0)
656 DEFINE_CLASS_ID(JumpProj, Proj, 1)
657 DEFINE_CLASS_ID(IfTrue, Proj, 2)
658 DEFINE_CLASS_ID(IfFalse, Proj, 3)
659 DEFINE_CLASS_ID(Parm, Proj, 4)
660 DEFINE_CLASS_ID(MachProj, Proj, 5)
661
662 DEFINE_CLASS_ID(Mem, Node, 4)
663 DEFINE_CLASS_ID(Load, Mem, 0)
664 DEFINE_CLASS_ID(LoadVector, Load, 0)
665 DEFINE_CLASS_ID(Store, Mem, 1)
666 DEFINE_CLASS_ID(StoreVector, Store, 0)
667 DEFINE_CLASS_ID(LoadStore, Mem, 2)
668
669 DEFINE_CLASS_ID(Region, Node, 5)
670 DEFINE_CLASS_ID(Loop, Region, 0)
671 DEFINE_CLASS_ID(Root, Loop, 0)
672 DEFINE_CLASS_ID(CountedLoop, Loop, 1)
673
674 DEFINE_CLASS_ID(Sub, Node, 6)
675 DEFINE_CLASS_ID(Cmp, Sub, 0)
676 DEFINE_CLASS_ID(FastLock, Cmp, 0)
677 DEFINE_CLASS_ID(FastUnlock, Cmp, 1)
678
764 DEFINE_CLASS_QUERY(CallStaticJava)
765 DEFINE_CLASS_QUERY(Catch)
766 DEFINE_CLASS_QUERY(CatchProj)
767 DEFINE_CLASS_QUERY(CheckCastPP)
768 DEFINE_CLASS_QUERY(CastII)
769 DEFINE_CLASS_QUERY(ConstraintCast)
770 DEFINE_CLASS_QUERY(ClearArray)
771 DEFINE_CLASS_QUERY(CMove)
772 DEFINE_CLASS_QUERY(Cmp)
773 DEFINE_CLASS_QUERY(CountedLoop)
774 DEFINE_CLASS_QUERY(CountedLoopEnd)
775 DEFINE_CLASS_QUERY(DecodeNarrowPtr)
776 DEFINE_CLASS_QUERY(DecodeN)
777 DEFINE_CLASS_QUERY(DecodeNKlass)
778 DEFINE_CLASS_QUERY(EncodeNarrowPtr)
779 DEFINE_CLASS_QUERY(EncodeP)
780 DEFINE_CLASS_QUERY(EncodePKlass)
781 DEFINE_CLASS_QUERY(FastLock)
782 DEFINE_CLASS_QUERY(FastUnlock)
783 DEFINE_CLASS_QUERY(If)
784 DEFINE_CLASS_QUERY(IfFalse)
785 DEFINE_CLASS_QUERY(IfTrue)
786 DEFINE_CLASS_QUERY(Initialize)
787 DEFINE_CLASS_QUERY(Jump)
788 DEFINE_CLASS_QUERY(JumpProj)
789 DEFINE_CLASS_QUERY(Load)
790 DEFINE_CLASS_QUERY(LoadStore)
791 DEFINE_CLASS_QUERY(Lock)
792 DEFINE_CLASS_QUERY(Loop)
793 DEFINE_CLASS_QUERY(Mach)
794 DEFINE_CLASS_QUERY(MachBranch)
795 DEFINE_CLASS_QUERY(MachCall)
796 DEFINE_CLASS_QUERY(MachCallDynamicJava)
797 DEFINE_CLASS_QUERY(MachCallJava)
798 DEFINE_CLASS_QUERY(MachCallLeaf)
799 DEFINE_CLASS_QUERY(MachCallRuntime)
800 DEFINE_CLASS_QUERY(MachCallStaticJava)
801 DEFINE_CLASS_QUERY(MachConstantBase)
802 DEFINE_CLASS_QUERY(MachConstant)
803 DEFINE_CLASS_QUERY(MachGoto)
804 DEFINE_CLASS_QUERY(MachIf)
805 DEFINE_CLASS_QUERY(MachNullCheck)
806 DEFINE_CLASS_QUERY(MachProj)
807 DEFINE_CLASS_QUERY(MachReturn)
808 DEFINE_CLASS_QUERY(MachSafePoint)
809 DEFINE_CLASS_QUERY(MachSpillCopy)
810 DEFINE_CLASS_QUERY(MachTemp)
811 DEFINE_CLASS_QUERY(MachMerge)
812 DEFINE_CLASS_QUERY(Mem)
813 DEFINE_CLASS_QUERY(MemBar)
814 DEFINE_CLASS_QUERY(MemBarStoreStore)
815 DEFINE_CLASS_QUERY(MergeMem)
816 DEFINE_CLASS_QUERY(Mul)
817 DEFINE_CLASS_QUERY(Multi)
818 DEFINE_CLASS_QUERY(MultiBranch)
819 DEFINE_CLASS_QUERY(Parm)
820 DEFINE_CLASS_QUERY(PCTable)
821 DEFINE_CLASS_QUERY(Phi)
822 DEFINE_CLASS_QUERY(Proj)
823 DEFINE_CLASS_QUERY(Region)
824 DEFINE_CLASS_QUERY(Root)
825 DEFINE_CLASS_QUERY(SafePoint)
826 DEFINE_CLASS_QUERY(SafePointScalarObject)
827 DEFINE_CLASS_QUERY(Start)
828 DEFINE_CLASS_QUERY(Store)
829 DEFINE_CLASS_QUERY(Sub)
830 DEFINE_CLASS_QUERY(Type)
831 DEFINE_CLASS_QUERY(Vector)
832 DEFINE_CLASS_QUERY(LoadVector)
833 DEFINE_CLASS_QUERY(StoreVector)
834 DEFINE_CLASS_QUERY(Unlock)
835
836 #undef DEFINE_CLASS_QUERY
837
838 // duplicate of is_MachSpillCopy()
839 bool is_SpillCopy () const {
840 return ((_class_id & ClassMask_MachSpillCopy) == Class_MachSpillCopy);
841 }
842
843 bool is_Con () const { return (_flags & Flag_is_Con) != 0; }
844 // The data node which is safe to leave in dead loop during IGVN optimization.
845 bool is_dead_loop_safe() const {
846 return is_Phi() || (is_Proj() && in(0) == NULL) ||
905 // Return the set of values this Node can take on at runtime.
906 virtual const Type *Value( PhaseTransform *phase ) const;
907
908 // Return a node which is more "ideal" than the current node.
909 // The invariants on this call are subtle. If in doubt, read the
910 // treatise in node.cpp above the default implemention AND TEST WITH
911 // +VerifyIterativeGVN!
912 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
913
914 // Some nodes have specific Ideal subgraph transformations only if they are
915 // unique users of specific nodes. Such nodes should be put on IGVN worklist
916 // for the transformations to happen.
917 bool has_special_unique_user() const;
918
919 // Skip Proj and CatchProj nodes chains. Check for Null and Top.
920 Node* find_exact_control(Node* ctrl);
921
922 // Check if 'this' node dominates or equal to 'sub'.
923 bool dominates(Node* sub, Node_List &nlist);
924
925 protected:
926 bool remove_dead_region(PhaseGVN *phase, bool can_reshape);
927 public:
928
929 // Idealize graph, using DU info. Done after constant propagation
930 virtual Node *Ideal_DU_postCCP( PhaseCCP *ccp );
931
932 // See if there is valid pipeline info
933 static const Pipeline *pipeline_class();
934 virtual const Pipeline *pipeline() const;
935
936 // Compute the latency from the def to this instruction of the ith input node
937 uint latency(uint i);
938
939 // Hash & compare functions, for pessimistic value numbering
940
941 // If the hash function returns the special sentinel value NO_HASH,
942 // the node is guaranteed never to compare equal to any other node.
943 // If we accidentally generate a hash with value NO_HASH the node
944 // won't go into the table and we'll lose a little optimization.
945 enum { NO_HASH = 0 };
946 virtual uint hash() const;
947 virtual uint cmp( const Node &n ) const;
948
949 // Operation appears to be iteratively computed (such as an induction variable)
950 // It is possible for this operation to return false for a loop-varying
951 // value, if it appears (by local graph inspection) to be computed by a simple conditional.
952 bool is_iteratively_computed();
953
954 // Determine if a node is Counted loop induction variable.
955 // The method is defined in loopnode.cpp.
956 const Node* is_loop_iv() const;
957
958 // Return a node with opcode "opc" and same inputs as "this" if one can
959 // be found; Otherwise return NULL;
960 Node* find_similar(int opc);
961
962 // Return the unique control out if only one. Null if none or more than one.
963 Node* unique_ctrl_out();
964
965 //----------------- Code Generation
966
967 // Ideal register class for Matching. Zero means unmatched instruction
968 // (these are cloned instead of converted to machine nodes).
969 virtual uint ideal_reg() const;
970
971 static const uint NotAMachineReg; // must be > max. machine register
972
973 // Do we Match on this edge index or not? Generally false for Control
974 // and true for everything else. Weird for calls & returns.
975 virtual uint match_edge(uint idx) const;
976
977 // Register class output is returned in
978 virtual const RegMask &out_RegMask() const;
979 // Register class input is expected in
980 virtual const RegMask &in_RegMask(uint) const;
981 // Should we clone rather than spill this instruction?
982 bool rematerialize() const;
983
|
54 class CatchNode;
55 class CatchProjNode;
56 class CheckCastPPNode;
57 class CastIINode;
58 class ClearArrayNode;
59 class CmpNode;
60 class CodeBuffer;
61 class ConstraintCastNode;
62 class ConNode;
63 class CountedLoopNode;
64 class CountedLoopEndNode;
65 class DecodeNarrowPtrNode;
66 class DecodeNNode;
67 class DecodeNKlassNode;
68 class EncodeNarrowPtrNode;
69 class EncodePNode;
70 class EncodePKlassNode;
71 class FastLockNode;
72 class FastUnlockNode;
73 class IfNode;
74 class IfProjNode;
75 class IfFalseNode;
76 class IfTrueNode;
77 class InitializeNode;
78 class JVMState;
79 class JumpNode;
80 class JumpProjNode;
81 class LoadNode;
82 class LoadStoreNode;
83 class LockNode;
84 class LoopNode;
85 class MachBranchNode;
86 class MachCallDynamicJavaNode;
87 class MachCallJavaNode;
88 class MachCallLeafNode;
89 class MachCallNode;
90 class MachCallRuntimeNode;
91 class MachCallStaticJavaNode;
92 class MachConstantBaseNode;
93 class MachConstantNode;
94 class MachGotoNode;
95 class MachIfNode;
96 class MachNode;
97 class MachNullCheckNode;
98 class MachProjNode;
99 class MachReturnNode;
100 class MachSafePointNode;
101 class MachSpillCopyNode;
102 class MachTempNode;
103 class MachMergeNode;
104 class MachMemBarNode;
105 class Matcher;
106 class MemBarNode;
107 class MemBarStoreStoreNode;
108 class MemNode;
109 class MergeMemNode;
110 class MulNode;
111 class MultiNode;
112 class MultiBranchNode;
113 class NeverBranchNode;
114 class Node;
115 class Node_Array;
116 class Node_List;
117 class Node_Stack;
118 class NullCheckNode;
119 class OopMap;
120 class ParmNode;
121 class PCTableNode;
122 class PhaseCCP;
123 class PhaseGVN;
124 class PhaseIterGVN;
125 class PhaseRegAlloc;
126 class PhaseTransform;
127 class PhaseValues;
128 class PhiNode;
129 class Pipeline;
130 class ProjNode;
131 class RegMask;
132 class RegionNode;
133 class RootNode;
134 class SafePointNode;
135 class SafePointScalarObjectNode;
136 class ShenandoahBarrierNode;
137 class StartNode;
138 class State;
139 class StoreNode;
140 class SubNode;
141 class Type;
142 class TypeNode;
143 class UnlockNode;
144 class VectorNode;
145 class LoadVectorNode;
146 class StoreVectorNode;
147 class VectorSet;
148 typedef void (*NFunc)(Node&,void*);
149 extern "C" {
150 typedef int (*C_sort_func_t)(const void *, const void *);
151 }
152
153 // The type of all node counts and indexes.
154 // It must hold at least 16 bits, but must also be fast to load and store.
155 // This type, if less than 32 bits, could limit the number of possible nodes.
156 // (To make this type platform-specific, move to globalDefinitions_xxx.hpp.)
439 int replace_edge(Node* old, Node* neww);
440 int replace_edges_in_range(Node* old, Node* neww, int start, int end);
441 // NULL out all inputs to eliminate incoming Def-Use edges.
442 // Return the number of edges between 'n' and 'this'
443 int disconnect_inputs(Node *n, Compile *c);
444
445 // Quickly, return true if and only if I am Compile::current()->top().
446 bool is_top() const {
447 assert((this == (Node*) Compile::current()->top()) == (_out == NULL), "");
448 return (_out == NULL);
449 }
450 // Reaffirm invariants for is_top. (Only from Compile::set_cached_top_node.)
451 void setup_is_top();
452
453 // Strip away casting. (It is depth-limited.)
454 Node* uncast() const;
455 // Return whether two Nodes are equivalent, after stripping casting.
456 bool eqv_uncast(const Node* n) const {
457 return (this->uncast() == n->uncast());
458 }
459 // Return true if the current node has an out that matches opcode.
460 bool has_out_with(int opcode);
461
462 // Find out of current node that matches opcode.
463 Node* find_out_with(int opcode);
464
465 private:
466 static Node* uncast_helper(const Node* n);
467
468 // Add an output edge to the end of the list
469 void add_out( Node *n ) {
470 if (is_top()) return;
471 if( _outcnt == _outmax ) out_grow(_outcnt);
472 _out[_outcnt++] = n;
473 }
474 // Delete an output edge
475 void del_out( Node *n ) {
476 if (is_top()) return;
477 Node** outp = &_out[_outcnt];
478 // Find and remove n
479 do {
480 assert(outp > _out, "Missing Def-Use edge");
624 DEFINE_CLASS_ID(MemBarStoreStore, MemBar, 1)
625
626 DEFINE_CLASS_ID(Mach, Node, 1)
627 DEFINE_CLASS_ID(MachReturn, Mach, 0)
628 DEFINE_CLASS_ID(MachSafePoint, MachReturn, 0)
629 DEFINE_CLASS_ID(MachCall, MachSafePoint, 0)
630 DEFINE_CLASS_ID(MachCallJava, MachCall, 0)
631 DEFINE_CLASS_ID(MachCallStaticJava, MachCallJava, 0)
632 DEFINE_CLASS_ID(MachCallDynamicJava, MachCallJava, 1)
633 DEFINE_CLASS_ID(MachCallRuntime, MachCall, 1)
634 DEFINE_CLASS_ID(MachCallLeaf, MachCallRuntime, 0)
635 DEFINE_CLASS_ID(MachBranch, Mach, 1)
636 DEFINE_CLASS_ID(MachIf, MachBranch, 0)
637 DEFINE_CLASS_ID(MachGoto, MachBranch, 1)
638 DEFINE_CLASS_ID(MachNullCheck, MachBranch, 2)
639 DEFINE_CLASS_ID(MachSpillCopy, Mach, 2)
640 DEFINE_CLASS_ID(MachTemp, Mach, 3)
641 DEFINE_CLASS_ID(MachConstantBase, Mach, 4)
642 DEFINE_CLASS_ID(MachConstant, Mach, 5)
643 DEFINE_CLASS_ID(MachMerge, Mach, 6)
644 DEFINE_CLASS_ID(MachMemBar, Mach, 7)
645
646 DEFINE_CLASS_ID(Type, Node, 2)
647 DEFINE_CLASS_ID(Phi, Type, 0)
648 DEFINE_CLASS_ID(ConstraintCast, Type, 1)
649 DEFINE_CLASS_ID(CastII, ConstraintCast, 0)
650 DEFINE_CLASS_ID(CheckCastPP, Type, 2)
651 DEFINE_CLASS_ID(CMove, Type, 3)
652 DEFINE_CLASS_ID(SafePointScalarObject, Type, 4)
653 DEFINE_CLASS_ID(DecodeNarrowPtr, Type, 5)
654 DEFINE_CLASS_ID(DecodeN, DecodeNarrowPtr, 0)
655 DEFINE_CLASS_ID(DecodeNKlass, DecodeNarrowPtr, 1)
656 DEFINE_CLASS_ID(EncodeNarrowPtr, Type, 6)
657 DEFINE_CLASS_ID(EncodeP, EncodeNarrowPtr, 0)
658 DEFINE_CLASS_ID(EncodePKlass, EncodeNarrowPtr, 1)
659 DEFINE_CLASS_ID(ShenandoahBarrier, Type, 7)
660
661 DEFINE_CLASS_ID(Proj, Node, 3)
662 DEFINE_CLASS_ID(CatchProj, Proj, 0)
663 DEFINE_CLASS_ID(JumpProj, Proj, 1)
664 DEFINE_CLASS_ID(IfProj, Proj, 2)
665 DEFINE_CLASS_ID(IfTrue, IfProj, 0)
666 DEFINE_CLASS_ID(IfFalse, IfProj, 1)
667 DEFINE_CLASS_ID(Parm, Proj, 4)
668 DEFINE_CLASS_ID(MachProj, Proj, 5)
669
670 DEFINE_CLASS_ID(Mem, Node, 4)
671 DEFINE_CLASS_ID(Load, Mem, 0)
672 DEFINE_CLASS_ID(LoadVector, Load, 0)
673 DEFINE_CLASS_ID(Store, Mem, 1)
674 DEFINE_CLASS_ID(StoreVector, Store, 0)
675 DEFINE_CLASS_ID(LoadStore, Mem, 2)
676
677 DEFINE_CLASS_ID(Region, Node, 5)
678 DEFINE_CLASS_ID(Loop, Region, 0)
679 DEFINE_CLASS_ID(Root, Loop, 0)
680 DEFINE_CLASS_ID(CountedLoop, Loop, 1)
681
682 DEFINE_CLASS_ID(Sub, Node, 6)
683 DEFINE_CLASS_ID(Cmp, Sub, 0)
684 DEFINE_CLASS_ID(FastLock, Cmp, 0)
685 DEFINE_CLASS_ID(FastUnlock, Cmp, 1)
686
772 DEFINE_CLASS_QUERY(CallStaticJava)
773 DEFINE_CLASS_QUERY(Catch)
774 DEFINE_CLASS_QUERY(CatchProj)
775 DEFINE_CLASS_QUERY(CheckCastPP)
776 DEFINE_CLASS_QUERY(CastII)
777 DEFINE_CLASS_QUERY(ConstraintCast)
778 DEFINE_CLASS_QUERY(ClearArray)
779 DEFINE_CLASS_QUERY(CMove)
780 DEFINE_CLASS_QUERY(Cmp)
781 DEFINE_CLASS_QUERY(CountedLoop)
782 DEFINE_CLASS_QUERY(CountedLoopEnd)
783 DEFINE_CLASS_QUERY(DecodeNarrowPtr)
784 DEFINE_CLASS_QUERY(DecodeN)
785 DEFINE_CLASS_QUERY(DecodeNKlass)
786 DEFINE_CLASS_QUERY(EncodeNarrowPtr)
787 DEFINE_CLASS_QUERY(EncodeP)
788 DEFINE_CLASS_QUERY(EncodePKlass)
789 DEFINE_CLASS_QUERY(FastLock)
790 DEFINE_CLASS_QUERY(FastUnlock)
791 DEFINE_CLASS_QUERY(If)
792 DEFINE_CLASS_QUERY(IfProj)
793 DEFINE_CLASS_QUERY(IfFalse)
794 DEFINE_CLASS_QUERY(IfTrue)
795 DEFINE_CLASS_QUERY(Initialize)
796 DEFINE_CLASS_QUERY(Jump)
797 DEFINE_CLASS_QUERY(JumpProj)
798 DEFINE_CLASS_QUERY(Load)
799 DEFINE_CLASS_QUERY(LoadStore)
800 DEFINE_CLASS_QUERY(Lock)
801 DEFINE_CLASS_QUERY(Loop)
802 DEFINE_CLASS_QUERY(Mach)
803 DEFINE_CLASS_QUERY(MachBranch)
804 DEFINE_CLASS_QUERY(MachCall)
805 DEFINE_CLASS_QUERY(MachCallDynamicJava)
806 DEFINE_CLASS_QUERY(MachCallJava)
807 DEFINE_CLASS_QUERY(MachCallLeaf)
808 DEFINE_CLASS_QUERY(MachCallRuntime)
809 DEFINE_CLASS_QUERY(MachCallStaticJava)
810 DEFINE_CLASS_QUERY(MachConstantBase)
811 DEFINE_CLASS_QUERY(MachConstant)
812 DEFINE_CLASS_QUERY(MachGoto)
813 DEFINE_CLASS_QUERY(MachIf)
814 DEFINE_CLASS_QUERY(MachNullCheck)
815 DEFINE_CLASS_QUERY(MachProj)
816 DEFINE_CLASS_QUERY(MachReturn)
817 DEFINE_CLASS_QUERY(MachSafePoint)
818 DEFINE_CLASS_QUERY(MachSpillCopy)
819 DEFINE_CLASS_QUERY(MachTemp)
820 DEFINE_CLASS_QUERY(MachMemBar)
821 DEFINE_CLASS_QUERY(MachMerge)
822 DEFINE_CLASS_QUERY(Mem)
823 DEFINE_CLASS_QUERY(MemBar)
824 DEFINE_CLASS_QUERY(MemBarStoreStore)
825 DEFINE_CLASS_QUERY(MergeMem)
826 DEFINE_CLASS_QUERY(Mul)
827 DEFINE_CLASS_QUERY(Multi)
828 DEFINE_CLASS_QUERY(MultiBranch)
829 DEFINE_CLASS_QUERY(Parm)
830 DEFINE_CLASS_QUERY(PCTable)
831 DEFINE_CLASS_QUERY(Phi)
832 DEFINE_CLASS_QUERY(Proj)
833 DEFINE_CLASS_QUERY(Region)
834 DEFINE_CLASS_QUERY(Root)
835 DEFINE_CLASS_QUERY(SafePoint)
836 DEFINE_CLASS_QUERY(SafePointScalarObject)
837 DEFINE_CLASS_QUERY(ShenandoahBarrier)
838 DEFINE_CLASS_QUERY(Start)
839 DEFINE_CLASS_QUERY(Store)
840 DEFINE_CLASS_QUERY(Sub)
841 DEFINE_CLASS_QUERY(Type)
842 DEFINE_CLASS_QUERY(Vector)
843 DEFINE_CLASS_QUERY(LoadVector)
844 DEFINE_CLASS_QUERY(StoreVector)
845 DEFINE_CLASS_QUERY(Unlock)
846
847 #undef DEFINE_CLASS_QUERY
848
849 // duplicate of is_MachSpillCopy()
850 bool is_SpillCopy () const {
851 return ((_class_id & ClassMask_MachSpillCopy) == Class_MachSpillCopy);
852 }
853
854 bool is_Con () const { return (_flags & Flag_is_Con) != 0; }
855 // The data node which is safe to leave in dead loop during IGVN optimization.
856 bool is_dead_loop_safe() const {
857 return is_Phi() || (is_Proj() && in(0) == NULL) ||
916 // Return the set of values this Node can take on at runtime.
917 virtual const Type *Value( PhaseTransform *phase ) const;
918
919 // Return a node which is more "ideal" than the current node.
920 // The invariants on this call are subtle. If in doubt, read the
921 // treatise in node.cpp above the default implemention AND TEST WITH
922 // +VerifyIterativeGVN!
923 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
924
925 // Some nodes have specific Ideal subgraph transformations only if they are
926 // unique users of specific nodes. Such nodes should be put on IGVN worklist
927 // for the transformations to happen.
928 bool has_special_unique_user() const;
929
930 // Skip Proj and CatchProj nodes chains. Check for Null and Top.
931 Node* find_exact_control(Node* ctrl);
932
933 // Check if 'this' node dominates or equal to 'sub'.
934 bool dominates(Node* sub, Node_List &nlist);
935
936 virtual bool is_g1_wb_pre_call() const { return false; }
937 virtual bool is_shenandoah_state_load() const { return false; }
938 virtual bool is_shenandoah_marking_if(PhaseTransform *phase) const { return false; }
939
940 protected:
941 bool remove_dead_region(PhaseGVN *phase, bool can_reshape);
942 public:
943
944 // See if there is valid pipeline info
945 static const Pipeline *pipeline_class();
946 virtual const Pipeline *pipeline() const;
947
948 // Compute the latency from the def to this instruction of the ith input node
949 uint latency(uint i);
950
951 // Hash & compare functions, for pessimistic value numbering
952
953 // If the hash function returns the special sentinel value NO_HASH,
954 // the node is guaranteed never to compare equal to any other node.
955 // If we accidentally generate a hash with value NO_HASH the node
956 // won't go into the table and we'll lose a little optimization.
957 enum { NO_HASH = 0 };
958 virtual uint hash() const;
959 virtual uint cmp( const Node &n ) const;
960
961 // Operation appears to be iteratively computed (such as an induction variable)
962 // It is possible for this operation to return false for a loop-varying
963 // value, if it appears (by local graph inspection) to be computed by a simple conditional.
964 bool is_iteratively_computed();
965
966 // Determine if a node is Counted loop induction variable.
967 // The method is defined in loopnode.cpp.
968 const Node* is_loop_iv() const;
969
970 // Return a node with opcode "opc" and same inputs as "this" if one can
971 // be found; Otherwise return NULL;
972 Node* find_similar(int opc);
973
974 // Return the unique control out if only one. Null if none or more than one.
975 Node* unique_ctrl_out();
976
977 // Set control or add control as precedence edge
978 void ensure_control_or_add_prec(Node* c);
979
980 //----------------- Code Generation
981
982 // Ideal register class for Matching. Zero means unmatched instruction
983 // (these are cloned instead of converted to machine nodes).
984 virtual uint ideal_reg() const;
985
986 static const uint NotAMachineReg; // must be > max. machine register
987
988 // Do we Match on this edge index or not? Generally false for Control
989 // and true for everything else. Weird for calls & returns.
990 virtual uint match_edge(uint idx) const;
991
992 // Register class output is returned in
993 virtual const RegMask &out_RegMask() const;
994 // Register class input is expected in
995 virtual const RegMask &in_RegMask(uint) const;
996 // Should we clone rather than spill this instruction?
997 bool rematerialize() const;
998
|