59 //------------------------------StartNode--------------------------------------
60 // The method start node
61 class StartNode : public MultiNode {
62 virtual bool cmp( const Node &n ) const;
63 virtual uint size_of() const; // Size is bigger
64 public:
65 const TypeTuple *_domain;
66 StartNode( Node *root, const TypeTuple *domain ) : MultiNode(2), _domain(domain) {
67 init_class_id(Class_Start);
68 init_req(0,this);
69 init_req(1,root);
70 }
71 virtual int Opcode() const;
72 virtual bool pinned() const { return true; };
73 virtual const Type *bottom_type() const;
74 virtual const TypePtr *adr_type() const { return TypePtr::BOTTOM; }
75 virtual const Type* Value(PhaseGVN* phase) const;
76 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
77 virtual void calling_convention( BasicType* sig_bt, VMRegPair *parm_reg, uint length ) const;
78 virtual const RegMask &in_RegMask(uint) const;
79 virtual Node *match( const ProjNode *proj, const Matcher *m );
80 virtual uint ideal_reg() const { return 0; }
81 #ifndef PRODUCT
82 virtual void dump_spec(outputStream *st) const;
83 virtual void dump_compact_spec(outputStream *st) const;
84 #endif
85 };
86
87 //------------------------------StartOSRNode-----------------------------------
88 // The method start node for on stack replacement code
89 class StartOSRNode : public StartNode {
90 public:
91 StartOSRNode( Node *root, const TypeTuple *domain ) : StartNode(root, domain) {}
92 virtual int Opcode() const;
93 static const TypeTuple *osr_domain();
94 };
95
96
97 //------------------------------ParmNode---------------------------------------
98 // Incoming parameters
99 class ParmNode : public ProjNode {
100 static const char * const names[TypeFunc::Parms+1];
101 public:
102 ParmNode( StartNode *src, uint con ) : ProjNode(src,con) {
103 init_class_id(Class_Parm);
104 }
105 virtual int Opcode() const;
106 virtual bool is_CFG() const { return (_con == TypeFunc::Control); }
107 virtual uint ideal_reg() const;
108 #ifndef PRODUCT
109 virtual void dump_spec(outputStream *st) const;
110 virtual void dump_compact_spec(outputStream *st) const;
111 #endif
112 };
113
542
543 virtual uint size_of() const { return sizeof(*this); }
544
545 // Assumes that "this" is an argument to a safepoint node "s", and that
546 // "new_call" is being created to correspond to "s". But the difference
547 // between the start index of the jvmstates of "new_call" and "s" is
548 // "jvms_adj". Produce and return a SafePointScalarObjectNode that
549 // corresponds appropriately to "this" in "new_call". Assumes that
550 // "sosn_map" is a map, specific to the translation of "s" to "new_call",
551 // mapping old SafePointScalarObjectNodes to new, to avoid multiple copies.
552 SafePointScalarObjectNode* clone(Dict* sosn_map, bool& new_node) const;
553
554 #ifndef PRODUCT
555 virtual void dump_spec(outputStream *st) const;
556 #endif
557 };
558
559
560 // Simple container for the outgoing projections of a call. Useful
561 // for serious surgery on calls.
562 class CallProjections : public StackObj {
563 public:
564 Node* fallthrough_proj;
565 Node* fallthrough_catchproj;
566 Node* fallthrough_memproj;
567 Node* fallthrough_ioproj;
568 Node* catchall_catchproj;
569 Node* catchall_memproj;
570 Node* catchall_ioproj;
571 Node* resproj;
572 Node* exobj;
573 };
574
575 class CallGenerator;
576
577 //------------------------------CallNode---------------------------------------
578 // Call nodes now subsume the function of debug nodes at callsites, so they
579 // contain the functionality of a full scope chain of debug nodes.
580 class CallNode : public SafePointNode {
581 friend class VMStructs;
582
583 protected:
584 bool may_modify_arraycopy_helper(const TypeOopPtr* dest_t, const TypeOopPtr* t_oop, PhaseTransform* phase);
585
586 public:
587 const TypeFunc* _tf; // Function type
588 address _entry_point; // Address of method being called
589 float _cnt; // Estimate of number of times called
590 CallGenerator* _generator; // corresponding CallGenerator for some late inline calls
591 const char* _name; // Printable name, if _method is NULL
592
593 CallNode(const TypeFunc* tf, address addr, const TypePtr* adr_type, JVMState* jvms = nullptr)
594 : SafePointNode(tf->domain()->cnt(), jvms, adr_type),
595 _tf(tf),
596 _entry_point(addr),
597 _cnt(COUNT_UNKNOWN),
598 _generator(NULL),
599 _name(NULL)
600 {
601 init_class_id(Class_Call);
602 }
603
604 const TypeFunc* tf() const { return _tf; }
605 const address entry_point() const { return _entry_point; }
606 const float cnt() const { return _cnt; }
607 CallGenerator* generator() const { return _generator; }
608
609 void set_tf(const TypeFunc* tf) { _tf = tf; }
610 void set_entry_point(address p) { _entry_point = p; }
611 void set_cnt(float c) { _cnt = c; }
612 void set_generator(CallGenerator* cg) { _generator = cg; }
613
614 virtual const Type* bottom_type() const;
615 virtual const Type* Value(PhaseGVN* phase) const;
616 virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
617 virtual Node* Identity(PhaseGVN* phase) { return this; }
618 virtual bool cmp(const Node &n) const;
619 virtual uint size_of() const = 0;
620 virtual void calling_convention(BasicType* sig_bt, VMRegPair* parm_regs, uint argcnt) const;
621 virtual Node* match(const ProjNode* proj, const Matcher* m);
622 virtual uint ideal_reg() const { return NotAMachineReg; }
623 // Are we guaranteed that this node is a safepoint? Not true for leaf calls and
624 // for some macro nodes whose expansion does not have a safepoint on the fast path.
625 virtual bool guaranteed_safepoint() { return true; }
626 // For macro nodes, the JVMState gets modified during expansion. If calls
627 // use MachConstantBase, it gets modified during matching. So when cloning
628 // the node the JVMState must be deep cloned. Default is to shallow clone.
629 virtual bool needs_deep_clone_jvms(Compile* C) { return C->needs_deep_clone_jvms(); }
630
631 // Returns true if the call may modify n
632 virtual bool may_modify(const TypeOopPtr* t_oop, PhaseTransform* phase);
633 // Does this node have a use of n other than in debug information?
634 bool has_non_debug_use(Node* n);
635 // Returns the unique CheckCastPP of a call
636 // or result projection is there are several CheckCastPP
637 // or returns NULL if there is no one.
638 Node* result_cast();
639 // Does this node returns pointer?
640 bool returns_pointer() const {
641 const TypeTuple* r = tf()->range();
642 return (r->cnt() > TypeFunc::Parms &&
643 r->field_at(TypeFunc::Parms)->isa_ptr());
644 }
645
646 // Collect all the interesting edges from a call for use in
647 // replacing the call by something else. Used by macro expansion
648 // and the late inlining support.
649 void extract_projections(CallProjections* projs, bool separate_io_proj, bool do_asserts = true);
650
651 virtual uint match_edge(uint idx) const;
652
653 bool is_call_to_arraycopystub() const;
654
655 virtual void copy_call_debug_info(PhaseIterGVN* phase, SafePointNode* sfpt) {}
656
657 #ifndef PRODUCT
658 virtual void dump_req(outputStream* st = tty, DumpConfig* dc = nullptr) const;
659 virtual void dump_spec(outputStream* st) const;
660 #endif
661 };
662
663
664 //------------------------------CallJavaNode-----------------------------------
665 // Make a static or dynamic subroutine call node using Java calling
666 // convention. (The "Java" calling convention is the compiler's calling
667 // convention, as opposed to the interpreter's or that of native C.)
668 class CallJavaNode : public CallNode {
669 friend class VMStructs;
699 bool override_symbolic_info() const { return _override_symbolic_info; }
700 void set_arg_escape(bool f) { _arg_escape = f; }
701 bool arg_escape() const { return _arg_escape; }
702 void copy_call_debug_info(PhaseIterGVN* phase, SafePointNode *sfpt);
703
704 DEBUG_ONLY( bool validate_symbolic_info() const; )
705
706 #ifndef PRODUCT
707 virtual void dump_spec(outputStream *st) const;
708 virtual void dump_compact_spec(outputStream *st) const;
709 #endif
710 };
711
712 //------------------------------CallStaticJavaNode-----------------------------
713 // Make a direct subroutine call using Java calling convention (for static
714 // calls and optimized virtual calls, plus calls to wrappers for run-time
715 // routines); generates static stub.
716 class CallStaticJavaNode : public CallJavaNode {
717 virtual bool cmp( const Node &n ) const;
718 virtual uint size_of() const; // Size is bigger
719 public:
720 CallStaticJavaNode(Compile* C, const TypeFunc* tf, address addr, ciMethod* method)
721 : CallJavaNode(tf, addr, method) {
722 init_class_id(Class_CallStaticJava);
723 if (C->eliminate_boxing() && (method != NULL) && method->is_boxing_method()) {
724 init_flags(Flag_is_macro);
725 C->add_macro_node(this);
726 }
727 }
728 CallStaticJavaNode(const TypeFunc* tf, address addr, const char* name, const TypePtr* adr_type)
729 : CallJavaNode(tf, addr, NULL) {
730 init_class_id(Class_CallStaticJava);
731 // This node calls a runtime stub, which often has narrow memory effects.
732 _adr_type = adr_type;
733 _name = name;
734 }
735
736 // If this is an uncommon trap, return the request code, else zero.
737 int uncommon_trap_request() const;
738 static int extract_uncommon_trap_request(const Node* call);
739
740 bool is_boxing_method() const {
741 return is_macro() && (method() != NULL) && method()->is_boxing_method();
742 }
743 // Late inlining modifies the JVMState, so we need to deep clone it
744 // when the call node is cloned (because it is macro node).
745 virtual bool needs_deep_clone_jvms(Compile* C) {
746 return is_boxing_method() || CallNode::needs_deep_clone_jvms(C);
816 }
817 virtual int Opcode() const;
818 virtual bool guaranteed_safepoint() { return false; }
819 #ifndef PRODUCT
820 virtual void dump_spec(outputStream *st) const;
821 #endif
822 };
823
824 //------------------------------CallLeafNoFPNode-------------------------------
825 // CallLeafNode, not using floating point or using it in the same manner as
826 // the generated code
827 class CallLeafNoFPNode : public CallLeafNode {
828 public:
829 CallLeafNoFPNode(const TypeFunc* tf, address addr, const char* name,
830 const TypePtr* adr_type)
831 : CallLeafNode(tf, addr, name, adr_type)
832 {
833 init_class_id(Class_CallLeafNoFP);
834 }
835 virtual int Opcode() const;
836 };
837
838 //------------------------------CallLeafVectorNode-------------------------------
839 // CallLeafNode but calling with vector calling convention instead.
840 class CallLeafVectorNode : public CallLeafNode {
841 private:
842 uint _num_bits;
843 protected:
844 virtual bool cmp( const Node &n ) const;
845 virtual uint size_of() const; // Size is bigger
846 public:
847 CallLeafVectorNode(const TypeFunc* tf, address addr, const char* name,
848 const TypePtr* adr_type, uint num_bits)
849 : CallLeafNode(tf, addr, name, adr_type), _num_bits(num_bits)
850 {
851 }
852 virtual int Opcode() const;
853 virtual void calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const;
854 };
855
857 //------------------------------Allocate---------------------------------------
858 // High-level memory allocation
859 //
860 // AllocateNode and AllocateArrayNode are subclasses of CallNode because they will
861 // get expanded into a code sequence containing a call. Unlike other CallNodes,
862 // they have 2 memory projections and 2 i_o projections (which are distinguished by
863 // the _is_io_use flag in the projection.) This is needed when expanding the node in
864 // order to differentiate the uses of the projection on the normal control path from
865 // those on the exception return path.
866 //
867 class AllocateNode : public CallNode {
868 public:
869 enum {
870 // Output:
871 RawAddress = TypeFunc::Parms, // the newly-allocated raw address
872 // Inputs:
873 AllocSize = TypeFunc::Parms, // size (in bytes) of the new object
874 KlassNode, // type (maybe dynamic) of the obj.
875 InitialTest, // slow-path test (may be constant)
876 ALength, // array length (or TOP if none)
877 ParmLimit
878 };
879
880 static const TypeFunc* alloc_type(const Type* t) {
881 const Type** fields = TypeTuple::fields(ParmLimit - TypeFunc::Parms);
882 fields[AllocSize] = TypeInt::POS;
883 fields[KlassNode] = TypeInstPtr::NOTNULL;
884 fields[InitialTest] = TypeInt::BOOL;
885 fields[ALength] = t; // length (can be a bad length)
886
887 const TypeTuple *domain = TypeTuple::make(ParmLimit, fields);
888
889 // create result type (range)
890 fields = TypeTuple::fields(1);
891 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
892
893 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
894
895 return TypeFunc::make(domain, range);
896 }
897
898 // Result of Escape Analysis
899 bool _is_scalar_replaceable;
900 bool _is_non_escaping;
901 // True when MemBar for new is redundant with MemBar at initialzer exit
902 bool _is_allocation_MemBar_redundant;
903
904 virtual uint size_of() const; // Size is bigger
905 AllocateNode(Compile* C, const TypeFunc *atype, Node *ctrl, Node *mem, Node *abio,
906 Node *size, Node *klass_node, Node *initial_test);
907 // Expansion modifies the JVMState, so we need to deep clone it
908 virtual bool needs_deep_clone_jvms(Compile* C) { return true; }
909 virtual int Opcode() const;
910 virtual uint ideal_reg() const { return Op_RegP; }
911 virtual bool guaranteed_safepoint() { return false; }
912
913 // allocations do not modify their arguments
914 virtual bool may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase) { return false;}
915
916 // Pattern-match a possible usage of AllocateNode.
917 // Return null if no allocation is recognized.
918 // The operand is the pointer produced by the (possible) allocation.
919 // It must be a projection of the Allocate or its subsequent CastPP.
920 // (Note: This function is defined in file graphKit.cpp, near
921 // GraphKit::new_instance/new_array, whose output it recognizes.)
922 // The 'ptr' may not have an offset unless the 'offset' argument is given.
923 static AllocateNode* Ideal_allocation(Node* ptr, PhaseTransform* phase);
924
925 // Fancy version which uses AddPNode::Ideal_base_and_offset to strip
926 // an offset, which is reported back to the caller.
951
952 // Return true if allocation doesn't escape thread, its escape state
953 // needs be noEscape or ArgEscape. InitializeNode._does_not_escape
954 // is true when its allocation's escape state is noEscape or
955 // ArgEscape. In case allocation's InitializeNode is NULL, check
956 // AlllocateNode._is_non_escaping flag.
957 // AlllocateNode._is_non_escaping is true when its escape state is
958 // noEscape.
959 bool does_not_escape_thread() {
960 InitializeNode* init = NULL;
961 return _is_non_escaping || (((init = initialization()) != NULL) && init->does_not_escape());
962 }
963
964 // If object doesn't escape in <.init> method and there is memory barrier
965 // inserted at exit of its <.init>, memory barrier for new is not necessary.
966 // Inovke this method when MemBar at exit of initializer and post-dominate
967 // allocation node.
968 void compute_MemBar_redundancy(ciMethod* initializer);
969 bool is_allocation_MemBar_redundant() { return _is_allocation_MemBar_redundant; }
970
971 Node* make_ideal_mark(PhaseGVN *phase, Node* obj, Node* control, Node* mem);
972 };
973
974 //------------------------------AllocateArray---------------------------------
975 //
976 // High-level array allocation
977 //
978 class AllocateArrayNode : public AllocateNode {
979 public:
980 AllocateArrayNode(Compile* C, const TypeFunc *atype, Node *ctrl, Node *mem, Node *abio,
981 Node* size, Node* klass_node, Node* initial_test,
982 Node* count_val
983 )
984 : AllocateNode(C, atype, ctrl, mem, abio, size, klass_node,
985 initial_test)
986 {
987 init_class_id(Class_AllocateArray);
988 set_req(AllocateNode::ALength, count_val);
989 }
990 virtual int Opcode() const;
991 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
992
993 // Dig the length operand out of a array allocation site.
994 Node* Ideal_length() {
995 return in(AllocateNode::ALength);
996 }
997
998 // Dig the length operand out of a array allocation site and narrow the
999 // type with a CastII, if necesssary
1000 Node* make_ideal_length(const TypeOopPtr* ary_type, PhaseTransform *phase, bool can_create = true);
1001
1002 // Pattern-match a possible usage of AllocateArrayNode.
1003 // Return null if no allocation is recognized.
1004 static AllocateArrayNode* Ideal_array_allocation(Node* ptr, PhaseTransform* phase) {
1005 AllocateNode* allo = Ideal_allocation(ptr, phase);
1006 return (allo == NULL || !allo->is_AllocateArray())
1007 ? NULL : allo->as_AllocateArray();
1008 }
1089 // 0 - object to lock
1090 // 1 - a BoxLockNode
1091 // 2 - a FastLockNode
1092 //
1093 class LockNode : public AbstractLockNode {
1094 public:
1095
1096 static const TypeFunc *lock_type() {
1097 // create input type (domain)
1098 const Type **fields = TypeTuple::fields(3);
1099 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
1100 fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // Address of stack location for lock
1101 fields[TypeFunc::Parms+2] = TypeInt::BOOL; // FastLock
1102 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+3,fields);
1103
1104 // create result type (range)
1105 fields = TypeTuple::fields(0);
1106
1107 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
1108
1109 return TypeFunc::make(domain,range);
1110 }
1111
1112 virtual int Opcode() const;
1113 virtual uint size_of() const; // Size is bigger
1114 LockNode(Compile* C, const TypeFunc *tf) : AbstractLockNode( tf ) {
1115 init_class_id(Class_Lock);
1116 init_flags(Flag_is_macro);
1117 C->add_macro_node(this);
1118 }
1119 virtual bool guaranteed_safepoint() { return false; }
1120
1121 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
1122 // Expansion modifies the JVMState, so we need to deep clone it
1123 virtual bool needs_deep_clone_jvms(Compile* C) { return true; }
1124
1125 bool is_nested_lock_region(); // Is this Lock nested?
1126 bool is_nested_lock_region(Compile * c); // Why isn't this Lock nested?
1127 };
1128
1129 //------------------------------Unlock---------------------------------------
|
59 //------------------------------StartNode--------------------------------------
60 // The method start node
61 class StartNode : public MultiNode {
62 virtual bool cmp( const Node &n ) const;
63 virtual uint size_of() const; // Size is bigger
64 public:
65 const TypeTuple *_domain;
66 StartNode( Node *root, const TypeTuple *domain ) : MultiNode(2), _domain(domain) {
67 init_class_id(Class_Start);
68 init_req(0,this);
69 init_req(1,root);
70 }
71 virtual int Opcode() const;
72 virtual bool pinned() const { return true; };
73 virtual const Type *bottom_type() const;
74 virtual const TypePtr *adr_type() const { return TypePtr::BOTTOM; }
75 virtual const Type* Value(PhaseGVN* phase) const;
76 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
77 virtual void calling_convention( BasicType* sig_bt, VMRegPair *parm_reg, uint length ) const;
78 virtual const RegMask &in_RegMask(uint) const;
79 virtual Node *match(const ProjNode *proj, const Matcher *m, const RegMask* mask);
80 virtual uint ideal_reg() const { return 0; }
81 #ifndef PRODUCT
82 virtual void dump_spec(outputStream *st) const;
83 virtual void dump_compact_spec(outputStream *st) const;
84 #endif
85 };
86
87 //------------------------------StartOSRNode-----------------------------------
88 // The method start node for on stack replacement code
89 class StartOSRNode : public StartNode {
90 public:
91 StartOSRNode( Node *root, const TypeTuple *domain ) : StartNode(root, domain) {}
92 virtual int Opcode() const;
93 };
94
95
96 //------------------------------ParmNode---------------------------------------
97 // Incoming parameters
98 class ParmNode : public ProjNode {
99 static const char * const names[TypeFunc::Parms+1];
100 public:
101 ParmNode( StartNode *src, uint con ) : ProjNode(src,con) {
102 init_class_id(Class_Parm);
103 }
104 virtual int Opcode() const;
105 virtual bool is_CFG() const { return (_con == TypeFunc::Control); }
106 virtual uint ideal_reg() const;
107 #ifndef PRODUCT
108 virtual void dump_spec(outputStream *st) const;
109 virtual void dump_compact_spec(outputStream *st) const;
110 #endif
111 };
112
541
542 virtual uint size_of() const { return sizeof(*this); }
543
544 // Assumes that "this" is an argument to a safepoint node "s", and that
545 // "new_call" is being created to correspond to "s". But the difference
546 // between the start index of the jvmstates of "new_call" and "s" is
547 // "jvms_adj". Produce and return a SafePointScalarObjectNode that
548 // corresponds appropriately to "this" in "new_call". Assumes that
549 // "sosn_map" is a map, specific to the translation of "s" to "new_call",
550 // mapping old SafePointScalarObjectNodes to new, to avoid multiple copies.
551 SafePointScalarObjectNode* clone(Dict* sosn_map, bool& new_node) const;
552
553 #ifndef PRODUCT
554 virtual void dump_spec(outputStream *st) const;
555 #endif
556 };
557
558
559 // Simple container for the outgoing projections of a call. Useful
560 // for serious surgery on calls.
561 class CallProjections {
562 public:
563 Node* fallthrough_proj;
564 Node* fallthrough_catchproj;
565 Node* fallthrough_memproj;
566 Node* fallthrough_ioproj;
567 Node* catchall_catchproj;
568 Node* catchall_memproj;
569 Node* catchall_ioproj;
570 Node* exobj;
571 uint nb_resproj;
572 Node* resproj[1]; // at least one projection
573
574 CallProjections(uint nbres) {
575 fallthrough_proj = NULL;
576 fallthrough_catchproj = NULL;
577 fallthrough_memproj = NULL;
578 fallthrough_ioproj = NULL;
579 catchall_catchproj = NULL;
580 catchall_memproj = NULL;
581 catchall_ioproj = NULL;
582 exobj = NULL;
583 nb_resproj = nbres;
584 resproj[0] = NULL;
585 for (uint i = 1; i < nb_resproj; i++) {
586 resproj[i] = NULL;
587 }
588 }
589
590 };
591
592 class CallGenerator;
593
594 //------------------------------CallNode---------------------------------------
595 // Call nodes now subsume the function of debug nodes at callsites, so they
596 // contain the functionality of a full scope chain of debug nodes.
597 class CallNode : public SafePointNode {
598 friend class VMStructs;
599
600 protected:
601 bool may_modify_arraycopy_helper(const TypeOopPtr* dest_t, const TypeOopPtr* t_oop, PhaseTransform* phase);
602
603 public:
604 const TypeFunc* _tf; // Function type
605 address _entry_point; // Address of method being called
606 float _cnt; // Estimate of number of times called
607 CallGenerator* _generator; // corresponding CallGenerator for some late inline calls
608 const char* _name; // Printable name, if _method is NULL
609
610 CallNode(const TypeFunc* tf, address addr, const TypePtr* adr_type, JVMState* jvms = nullptr)
611 : SafePointNode(tf->domain_cc()->cnt(), jvms, adr_type),
612 _tf(tf),
613 _entry_point(addr),
614 _cnt(COUNT_UNKNOWN),
615 _generator(NULL),
616 _name(NULL)
617 {
618 init_class_id(Class_Call);
619 }
620
621 const TypeFunc* tf() const { return _tf; }
622 const address entry_point() const { return _entry_point; }
623 const float cnt() const { return _cnt; }
624 CallGenerator* generator() const { return _generator; }
625
626 void set_tf(const TypeFunc* tf) { _tf = tf; }
627 void set_entry_point(address p) { _entry_point = p; }
628 void set_cnt(float c) { _cnt = c; }
629 void set_generator(CallGenerator* cg) { _generator = cg; }
630
631 virtual const Type* bottom_type() const;
632 virtual const Type* Value(PhaseGVN* phase) const;
633 virtual Node* Ideal(PhaseGVN* phase, bool can_reshape);
634 virtual Node* Identity(PhaseGVN* phase) { return this; }
635 virtual bool cmp(const Node &n) const;
636 virtual uint size_of() const = 0;
637 virtual void calling_convention(BasicType* sig_bt, VMRegPair* parm_regs, uint argcnt) const;
638 virtual Node* match(const ProjNode* proj, const Matcher* m, const RegMask* mask);
639 virtual uint ideal_reg() const { return NotAMachineReg; }
640 // Are we guaranteed that this node is a safepoint? Not true for leaf calls and
641 // for some macro nodes whose expansion does not have a safepoint on the fast path.
642 virtual bool guaranteed_safepoint() { return true; }
643 // For macro nodes, the JVMState gets modified during expansion. If calls
644 // use MachConstantBase, it gets modified during matching. So when cloning
645 // the node the JVMState must be deep cloned. Default is to shallow clone.
646 virtual bool needs_deep_clone_jvms(Compile* C) { return C->needs_deep_clone_jvms(); }
647
648 // Returns true if the call may modify n
649 virtual bool may_modify(const TypeOopPtr* t_oop, PhaseTransform* phase);
650 // Does this node have a use of n other than in debug information?
651 bool has_non_debug_use(Node* n);
652 bool has_debug_use(Node* n);
653 // Returns the unique CheckCastPP of a call
654 // or result projection is there are several CheckCastPP
655 // or returns NULL if there is no one.
656 Node* result_cast();
657 // Does this node returns pointer?
658 bool returns_pointer() const {
659 const TypeTuple* r = tf()->range_sig();
660 return (!tf()->returns_inline_type_as_fields() &&
661 r->cnt() > TypeFunc::Parms &&
662 r->field_at(TypeFunc::Parms)->isa_ptr());
663 }
664
665 // Collect all the interesting edges from a call for use in
666 // replacing the call by something else. Used by macro expansion
667 // and the late inlining support.
668 CallProjections* extract_projections(bool separate_io_proj, bool do_asserts = true);
669
670 virtual uint match_edge(uint idx) const;
671
672 bool is_call_to_arraycopystub() const;
673
674 virtual void copy_call_debug_info(PhaseIterGVN* phase, SafePointNode* sfpt) {}
675
676 #ifndef PRODUCT
677 virtual void dump_req(outputStream* st = tty, DumpConfig* dc = nullptr) const;
678 virtual void dump_spec(outputStream* st) const;
679 #endif
680 };
681
682
683 //------------------------------CallJavaNode-----------------------------------
684 // Make a static or dynamic subroutine call node using Java calling
685 // convention. (The "Java" calling convention is the compiler's calling
686 // convention, as opposed to the interpreter's or that of native C.)
687 class CallJavaNode : public CallNode {
688 friend class VMStructs;
718 bool override_symbolic_info() const { return _override_symbolic_info; }
719 void set_arg_escape(bool f) { _arg_escape = f; }
720 bool arg_escape() const { return _arg_escape; }
721 void copy_call_debug_info(PhaseIterGVN* phase, SafePointNode *sfpt);
722
723 DEBUG_ONLY( bool validate_symbolic_info() const; )
724
725 #ifndef PRODUCT
726 virtual void dump_spec(outputStream *st) const;
727 virtual void dump_compact_spec(outputStream *st) const;
728 #endif
729 };
730
731 //------------------------------CallStaticJavaNode-----------------------------
732 // Make a direct subroutine call using Java calling convention (for static
733 // calls and optimized virtual calls, plus calls to wrappers for run-time
734 // routines); generates static stub.
735 class CallStaticJavaNode : public CallJavaNode {
736 virtual bool cmp( const Node &n ) const;
737 virtual uint size_of() const; // Size is bigger
738
739 bool remove_useless_allocation(PhaseGVN *phase, Node* ctl, Node* mem, Node* unc_arg);
740
741 public:
742 CallStaticJavaNode(Compile* C, const TypeFunc* tf, address addr, ciMethod* method)
743 : CallJavaNode(tf, addr, method) {
744 init_class_id(Class_CallStaticJava);
745 if (C->eliminate_boxing() && (method != NULL) && method->is_boxing_method()) {
746 init_flags(Flag_is_macro);
747 C->add_macro_node(this);
748 }
749 const TypeTuple *r = tf->range_sig();
750 if (InlineTypeReturnedAsFields &&
751 method != NULL &&
752 method->is_method_handle_intrinsic() &&
753 r->cnt() > TypeFunc::Parms &&
754 r->field_at(TypeFunc::Parms)->isa_oopptr() &&
755 r->field_at(TypeFunc::Parms)->is_oopptr()->can_be_inline_type()) {
756 // Make sure this call is processed by PhaseMacroExpand::expand_mh_intrinsic_return
757 init_flags(Flag_is_macro);
758 C->add_macro_node(this);
759 }
760 }
761 CallStaticJavaNode(const TypeFunc* tf, address addr, const char* name, const TypePtr* adr_type)
762 : CallJavaNode(tf, addr, NULL) {
763 init_class_id(Class_CallStaticJava);
764 // This node calls a runtime stub, which often has narrow memory effects.
765 _adr_type = adr_type;
766 _name = name;
767 }
768
769 // If this is an uncommon trap, return the request code, else zero.
770 int uncommon_trap_request() const;
771 static int extract_uncommon_trap_request(const Node* call);
772
773 bool is_boxing_method() const {
774 return is_macro() && (method() != NULL) && method()->is_boxing_method();
775 }
776 // Late inlining modifies the JVMState, so we need to deep clone it
777 // when the call node is cloned (because it is macro node).
778 virtual bool needs_deep_clone_jvms(Compile* C) {
779 return is_boxing_method() || CallNode::needs_deep_clone_jvms(C);
849 }
850 virtual int Opcode() const;
851 virtual bool guaranteed_safepoint() { return false; }
852 #ifndef PRODUCT
853 virtual void dump_spec(outputStream *st) const;
854 #endif
855 };
856
857 //------------------------------CallLeafNoFPNode-------------------------------
858 // CallLeafNode, not using floating point or using it in the same manner as
859 // the generated code
860 class CallLeafNoFPNode : public CallLeafNode {
861 public:
862 CallLeafNoFPNode(const TypeFunc* tf, address addr, const char* name,
863 const TypePtr* adr_type)
864 : CallLeafNode(tf, addr, name, adr_type)
865 {
866 init_class_id(Class_CallLeafNoFP);
867 }
868 virtual int Opcode() const;
869 virtual uint match_edge(uint idx) const;
870 };
871
872 //------------------------------CallLeafVectorNode-------------------------------
873 // CallLeafNode but calling with vector calling convention instead.
874 class CallLeafVectorNode : public CallLeafNode {
875 private:
876 uint _num_bits;
877 protected:
878 virtual bool cmp( const Node &n ) const;
879 virtual uint size_of() const; // Size is bigger
880 public:
881 CallLeafVectorNode(const TypeFunc* tf, address addr, const char* name,
882 const TypePtr* adr_type, uint num_bits)
883 : CallLeafNode(tf, addr, name, adr_type), _num_bits(num_bits)
884 {
885 }
886 virtual int Opcode() const;
887 virtual void calling_convention( BasicType* sig_bt, VMRegPair *parm_regs, uint argcnt ) const;
888 };
889
891 //------------------------------Allocate---------------------------------------
892 // High-level memory allocation
893 //
894 // AllocateNode and AllocateArrayNode are subclasses of CallNode because they will
895 // get expanded into a code sequence containing a call. Unlike other CallNodes,
896 // they have 2 memory projections and 2 i_o projections (which are distinguished by
897 // the _is_io_use flag in the projection.) This is needed when expanding the node in
898 // order to differentiate the uses of the projection on the normal control path from
899 // those on the exception return path.
900 //
901 class AllocateNode : public CallNode {
902 public:
903 enum {
904 // Output:
905 RawAddress = TypeFunc::Parms, // the newly-allocated raw address
906 // Inputs:
907 AllocSize = TypeFunc::Parms, // size (in bytes) of the new object
908 KlassNode, // type (maybe dynamic) of the obj.
909 InitialTest, // slow-path test (may be constant)
910 ALength, // array length (or TOP if none)
911 InlineTypeNode, // InlineTypeNode if this is an inline type allocation
912 DefaultValue, // default value in case of non-flattened inline type array
913 RawDefaultValue, // same as above but as raw machine word
914 ParmLimit
915 };
916
917 static const TypeFunc* alloc_type(const Type* t) {
918 const Type** fields = TypeTuple::fields(ParmLimit - TypeFunc::Parms);
919 fields[AllocSize] = TypeInt::POS;
920 fields[KlassNode] = TypeInstPtr::NOTNULL;
921 fields[InitialTest] = TypeInt::BOOL;
922 fields[ALength] = t; // length (can be a bad length)
923 fields[InlineTypeNode] = Type::BOTTOM;
924 fields[DefaultValue] = TypeInstPtr::NOTNULL;
925 fields[RawDefaultValue] = TypeX_X;
926
927 const TypeTuple *domain = TypeTuple::make(ParmLimit, fields);
928
929 // create result type (range)
930 fields = TypeTuple::fields(1);
931 fields[TypeFunc::Parms+0] = TypeRawPtr::NOTNULL; // Returned oop
932
933 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+1, fields);
934
935 return TypeFunc::make(domain, range);
936 }
937
938 // Result of Escape Analysis
939 bool _is_scalar_replaceable;
940 bool _is_non_escaping;
941 // True when MemBar for new is redundant with MemBar at initialzer exit
942 bool _is_allocation_MemBar_redundant;
943 bool _larval;
944
945 virtual uint size_of() const; // Size is bigger
946 AllocateNode(Compile* C, const TypeFunc *atype, Node *ctrl, Node *mem, Node *abio,
947 Node *size, Node *klass_node, Node *initial_test,
948 InlineTypeBaseNode* inline_type_node = NULL);
949 // Expansion modifies the JVMState, so we need to deep clone it
950 virtual bool needs_deep_clone_jvms(Compile* C) { return true; }
951 virtual int Opcode() const;
952 virtual uint ideal_reg() const { return Op_RegP; }
953 virtual bool guaranteed_safepoint() { return false; }
954
955 // allocations do not modify their arguments
956 virtual bool may_modify(const TypeOopPtr *t_oop, PhaseTransform *phase) { return false;}
957
958 // Pattern-match a possible usage of AllocateNode.
959 // Return null if no allocation is recognized.
960 // The operand is the pointer produced by the (possible) allocation.
961 // It must be a projection of the Allocate or its subsequent CastPP.
962 // (Note: This function is defined in file graphKit.cpp, near
963 // GraphKit::new_instance/new_array, whose output it recognizes.)
964 // The 'ptr' may not have an offset unless the 'offset' argument is given.
965 static AllocateNode* Ideal_allocation(Node* ptr, PhaseTransform* phase);
966
967 // Fancy version which uses AddPNode::Ideal_base_and_offset to strip
968 // an offset, which is reported back to the caller.
993
994 // Return true if allocation doesn't escape thread, its escape state
995 // needs be noEscape or ArgEscape. InitializeNode._does_not_escape
996 // is true when its allocation's escape state is noEscape or
997 // ArgEscape. In case allocation's InitializeNode is NULL, check
998 // AlllocateNode._is_non_escaping flag.
999 // AlllocateNode._is_non_escaping is true when its escape state is
1000 // noEscape.
1001 bool does_not_escape_thread() {
1002 InitializeNode* init = NULL;
1003 return _is_non_escaping || (((init = initialization()) != NULL) && init->does_not_escape());
1004 }
1005
1006 // If object doesn't escape in <.init> method and there is memory barrier
1007 // inserted at exit of its <.init>, memory barrier for new is not necessary.
1008 // Inovke this method when MemBar at exit of initializer and post-dominate
1009 // allocation node.
1010 void compute_MemBar_redundancy(ciMethod* initializer);
1011 bool is_allocation_MemBar_redundant() { return _is_allocation_MemBar_redundant; }
1012
1013 Node* make_ideal_mark(PhaseGVN* phase, Node* control, Node* mem);
1014 };
1015
1016 //------------------------------AllocateArray---------------------------------
1017 //
1018 // High-level array allocation
1019 //
1020 class AllocateArrayNode : public AllocateNode {
1021 public:
1022 AllocateArrayNode(Compile* C, const TypeFunc *atype, Node *ctrl, Node *mem, Node *abio,
1023 Node* size, Node* klass_node, Node* initial_test,
1024 Node* count_val,
1025 Node* default_value, Node* raw_default_value
1026 )
1027 : AllocateNode(C, atype, ctrl, mem, abio, size, klass_node,
1028 initial_test)
1029 {
1030 init_class_id(Class_AllocateArray);
1031 set_req(AllocateNode::ALength, count_val);
1032 init_req(AllocateNode::DefaultValue, default_value);
1033 init_req(AllocateNode::RawDefaultValue, raw_default_value);
1034 }
1035 virtual int Opcode() const;
1036 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
1037
1038 // Dig the length operand out of a array allocation site.
1039 Node* Ideal_length() {
1040 return in(AllocateNode::ALength);
1041 }
1042
1043 // Dig the length operand out of a array allocation site and narrow the
1044 // type with a CastII, if necesssary
1045 Node* make_ideal_length(const TypeOopPtr* ary_type, PhaseTransform *phase, bool can_create = true);
1046
1047 // Pattern-match a possible usage of AllocateArrayNode.
1048 // Return null if no allocation is recognized.
1049 static AllocateArrayNode* Ideal_array_allocation(Node* ptr, PhaseTransform* phase) {
1050 AllocateNode* allo = Ideal_allocation(ptr, phase);
1051 return (allo == NULL || !allo->is_AllocateArray())
1052 ? NULL : allo->as_AllocateArray();
1053 }
1134 // 0 - object to lock
1135 // 1 - a BoxLockNode
1136 // 2 - a FastLockNode
1137 //
1138 class LockNode : public AbstractLockNode {
1139 public:
1140
1141 static const TypeFunc *lock_type() {
1142 // create input type (domain)
1143 const Type **fields = TypeTuple::fields(3);
1144 fields[TypeFunc::Parms+0] = TypeInstPtr::NOTNULL; // Object to be Locked
1145 fields[TypeFunc::Parms+1] = TypeRawPtr::BOTTOM; // Address of stack location for lock
1146 fields[TypeFunc::Parms+2] = TypeInt::BOOL; // FastLock
1147 const TypeTuple *domain = TypeTuple::make(TypeFunc::Parms+3,fields);
1148
1149 // create result type (range)
1150 fields = TypeTuple::fields(0);
1151
1152 const TypeTuple *range = TypeTuple::make(TypeFunc::Parms+0,fields);
1153
1154 return TypeFunc::make(domain, range);
1155 }
1156
1157 virtual int Opcode() const;
1158 virtual uint size_of() const; // Size is bigger
1159 LockNode(Compile* C, const TypeFunc *tf) : AbstractLockNode( tf ) {
1160 init_class_id(Class_Lock);
1161 init_flags(Flag_is_macro);
1162 C->add_macro_node(this);
1163 }
1164 virtual bool guaranteed_safepoint() { return false; }
1165
1166 virtual Node *Ideal(PhaseGVN *phase, bool can_reshape);
1167 // Expansion modifies the JVMState, so we need to deep clone it
1168 virtual bool needs_deep_clone_jvms(Compile* C) { return true; }
1169
1170 bool is_nested_lock_region(); // Is this Lock nested?
1171 bool is_nested_lock_region(Compile * c); // Why isn't this Lock nested?
1172 };
1173
1174 //------------------------------Unlock---------------------------------------
|