801 void add_range_check_cast(Node* n);
802 void remove_range_check_cast(Node* n) {
803 if (_range_check_casts->contains(n)) {
804 _range_check_casts->remove(n);
805 }
806 }
807 Node* range_check_cast_node(int idx) const { return _range_check_casts->at(idx); }
808 int range_check_cast_count() const { return _range_check_casts->length(); }
809 // Remove all range check dependent CastIINodes.
810 void remove_range_check_casts(PhaseIterGVN &igvn);
811
812 void add_value_type_ptr(ValueTypePtrNode* n);
813 void remove_value_type_ptr(ValueTypePtrNode* n) {
814 if (_value_type_ptr_nodes->contains(n)) {
815 _value_type_ptr_nodes->remove(n);
816 }
817 }
818 ValueTypePtrNode* value_type_ptr(int idx) const { return _value_type_ptr_nodes->at(idx); }
819 int value_type_ptr_count() const { return _value_type_ptr_nodes->length(); }
820 void process_value_type_ptr_nodes(PhaseIterGVN &igvn);
821
822 // remove the opaque nodes that protect the predicates so that the unused checks and
823 // uncommon traps will be eliminated from the graph.
824 void cleanup_loop_predicates(PhaseIterGVN &igvn);
825 bool is_predicate_opaq(Node * n) {
826 return _predicate_opaqs->contains(n);
827 }
828
829 // Are there candidate expensive nodes for optimization?
830 bool should_optimize_expensive_nodes(PhaseIterGVN &igvn);
831 // Check whether n1 and n2 are similar
832 static int cmp_expensive_nodes(Node* n1, Node* n2);
833 // Sort expensive nodes to locate similar expensive nodes
834 void sort_expensive_nodes();
835
836 // Compilation environment.
837 Arena* comp_arena() { return &_comp_arena; }
838 ciEnv* env() const { return _env; }
839 CompileLog* log() const { return _log; }
840 bool failing() const { return _env->failing() || _failure_reason != NULL; }
1331 // Definitions of pd methods
1332 static void pd_compiler2_init();
1333
1334 // Static parse-time type checking logic for gen_subtype_check:
1335 enum { SSC_always_false, SSC_always_true, SSC_easy_test, SSC_full_test };
1336 int static_subtype_check(ciKlass* superk, ciKlass* subk);
1337
1338 static Node* conv_I2X_index(PhaseGVN* phase, Node* offset, const TypeInt* sizetype,
1339 // Optional control dependency (for example, on range check)
1340 Node* ctrl = NULL);
1341
1342 // Convert integer value to a narrowed long type dependent on ctrl (for example, a range check)
1343 static Node* constrained_convI2L(PhaseGVN* phase, Node* value, const TypeInt* itype, Node* ctrl);
1344
1345 // Auxiliary method for randomized fuzzing/stressing
1346 static bool randomized_select(int count);
1347
1348 // supporting clone_map
1349 CloneMap& clone_map();
1350 void set_clone_map(Dict* d);
1351
1352 // Create value type node from arguments at method entry
1353 Node* create_vt_node(Node* n, ciValueKlass* vk, ciValueKlass* base_vk, int base_offset, int base_input, bool in);
1354
1355 void add_safepoint_edges(SafePointNode* call, JVMState* youngest_jvms, bool can_prune_locals = false, uint stack_slots_not_pruned = 0);
1356 };
1357
1358 #endif // SHARE_VM_OPTO_COMPILE_HPP
|
801 void add_range_check_cast(Node* n);
802 void remove_range_check_cast(Node* n) {
803 if (_range_check_casts->contains(n)) {
804 _range_check_casts->remove(n);
805 }
806 }
807 Node* range_check_cast_node(int idx) const { return _range_check_casts->at(idx); }
808 int range_check_cast_count() const { return _range_check_casts->length(); }
809 // Remove all range check dependent CastIINodes.
810 void remove_range_check_casts(PhaseIterGVN &igvn);
811
812 void add_value_type_ptr(ValueTypePtrNode* n);
813 void remove_value_type_ptr(ValueTypePtrNode* n) {
814 if (_value_type_ptr_nodes->contains(n)) {
815 _value_type_ptr_nodes->remove(n);
816 }
817 }
818 ValueTypePtrNode* value_type_ptr(int idx) const { return _value_type_ptr_nodes->at(idx); }
819 int value_type_ptr_count() const { return _value_type_ptr_nodes->length(); }
820 void process_value_type_ptr_nodes(PhaseIterGVN &igvn);
821 bool can_add_value_type_ptr() const { return _value_type_ptr_nodes != NULL; }
822
823 // remove the opaque nodes that protect the predicates so that the unused checks and
824 // uncommon traps will be eliminated from the graph.
825 void cleanup_loop_predicates(PhaseIterGVN &igvn);
826 bool is_predicate_opaq(Node * n) {
827 return _predicate_opaqs->contains(n);
828 }
829
830 // Are there candidate expensive nodes for optimization?
831 bool should_optimize_expensive_nodes(PhaseIterGVN &igvn);
832 // Check whether n1 and n2 are similar
833 static int cmp_expensive_nodes(Node* n1, Node* n2);
834 // Sort expensive nodes to locate similar expensive nodes
835 void sort_expensive_nodes();
836
837 // Compilation environment.
838 Arena* comp_arena() { return &_comp_arena; }
839 ciEnv* env() const { return _env; }
840 CompileLog* log() const { return _log; }
841 bool failing() const { return _env->failing() || _failure_reason != NULL; }
1332 // Definitions of pd methods
1333 static void pd_compiler2_init();
1334
1335 // Static parse-time type checking logic for gen_subtype_check:
1336 enum { SSC_always_false, SSC_always_true, SSC_easy_test, SSC_full_test };
1337 int static_subtype_check(ciKlass* superk, ciKlass* subk);
1338
1339 static Node* conv_I2X_index(PhaseGVN* phase, Node* offset, const TypeInt* sizetype,
1340 // Optional control dependency (for example, on range check)
1341 Node* ctrl = NULL);
1342
1343 // Convert integer value to a narrowed long type dependent on ctrl (for example, a range check)
1344 static Node* constrained_convI2L(PhaseGVN* phase, Node* value, const TypeInt* itype, Node* ctrl);
1345
1346 // Auxiliary method for randomized fuzzing/stressing
1347 static bool randomized_select(int count);
1348
1349 // supporting clone_map
1350 CloneMap& clone_map();
1351 void set_clone_map(Dict* d);
1352
1353 void add_safepoint_edges(SafePointNode* call, JVMState* youngest_jvms, bool can_prune_locals = false, uint stack_slots_not_pruned = 0);
1354 };
1355
1356 #endif // SHARE_VM_OPTO_COMPILE_HPP
|