Mercurial > hg > truffle

comparison src/share/vm/opto/gcm.cpp @ 1685:0e35fa8ebccd

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
6973963: SEGV in ciBlock::start_bci() with EA Summary: Added more checks into ResourceObj and growableArray to verify correctness of allocation type. Reviewed-by: never, coleenp, dholmes
author kvn
date Tue, 03 Aug 2010 15:55:03 -0700
parents c18cbe5936b8
children f95d63e2154a
comparison
equal deleted inserted replaced
1684:66c5dadb4d61 1685:0e35fa8ebccd
839 void PhaseCFG::partial_latency_of_defs(Node *n) { 839 void PhaseCFG::partial_latency_of_defs(Node *n) {
840 // Set the latency for this instruction 840 // Set the latency for this instruction
841 #ifndef PRODUCT 841 #ifndef PRODUCT
842 if (trace_opto_pipelining()) { 842 if (trace_opto_pipelining()) {
843 tty->print("# latency_to_inputs: node_latency[%d] = %d for node", 843 tty->print("# latency_to_inputs: node_latency[%d] = %d for node",
844 n->_idx, _node_latency.at_grow(n->_idx)); 844 n->_idx, _node_latency->at_grow(n->_idx));
845 dump(); 845 dump();
846 } 846 }
847 #endif 847 #endif
848 848
849 if (n->is_Proj()) 849 if (n->is_Proj())
851 851
852 if (n->is_Root()) 852 if (n->is_Root())
853 return; 853 return;
854 854
855 uint nlen = n->len(); 855 uint nlen = n->len();
856 uint use_latency = _node_latency.at_grow(n->_idx); 856 uint use_latency = _node_latency->at_grow(n->_idx);
857 uint use_pre_order = _bbs[n->_idx]->_pre_order; 857 uint use_pre_order = _bbs[n->_idx]->_pre_order;
858 858
859 for ( uint j=0; j<nlen; j++ ) { 859 for ( uint j=0; j<nlen; j++ ) {
860 Node *def = n->in(j); 860 Node *def = n->in(j);
861 861
882 continue; 882 continue;
883 883
884 uint delta_latency = n->latency(j); 884 uint delta_latency = n->latency(j);
885 uint current_latency = delta_latency + use_latency; 885 uint current_latency = delta_latency + use_latency;
886 886
887 if (_node_latency.at_grow(def->_idx) < current_latency) { 887 if (_node_latency->at_grow(def->_idx) < current_latency) {
888 _node_latency.at_put_grow(def->_idx, current_latency); 888 _node_latency->at_put_grow(def->_idx, current_latency);
889 } 889 }
890 890
891 #ifndef PRODUCT 891 #ifndef PRODUCT
892 if (trace_opto_pipelining()) { 892 if (trace_opto_pipelining()) {
893 tty->print_cr("# %d + edge_latency(%d) == %d -> %d, node_latency[%d] = %d", 893 tty->print_cr("# %d + edge_latency(%d) == %d -> %d, node_latency[%d] = %d",
894 use_latency, j, delta_latency, current_latency, def->_idx, 894 use_latency, j, delta_latency, current_latency, def->_idx,
895 _node_latency.at_grow(def->_idx)); 895 _node_latency->at_grow(def->_idx));
896 } 896 }
897 #endif 897 #endif
898 } 898 }
899 } 899 }
900 900
924 924
925 if (use_pre_order == def_pre_order && use->is_Phi()) 925 if (use_pre_order == def_pre_order && use->is_Phi())
926 return 0; 926 return 0;
927 927
928 uint nlen = use->len(); 928 uint nlen = use->len();
929 uint nl = _node_latency.at_grow(use->_idx); 929 uint nl = _node_latency->at_grow(use->_idx);
930 930
931 for ( uint j=0; j<nlen; j++ ) { 931 for ( uint j=0; j<nlen; j++ ) {
932 if (use->in(j) == n) { 932 if (use->in(j) == n) {
933 // Change this if we want local latencies 933 // Change this if we want local latencies
934 uint ul = use->latency(j); 934 uint ul = use->latency(j);
960 void PhaseCFG::latency_from_uses(Node *n) { 960 void PhaseCFG::latency_from_uses(Node *n) {
961 // Set the latency for this instruction 961 // Set the latency for this instruction
962 #ifndef PRODUCT 962 #ifndef PRODUCT
963 if (trace_opto_pipelining()) { 963 if (trace_opto_pipelining()) {
964 tty->print("# latency_from_outputs: node_latency[%d] = %d for node", 964 tty->print("# latency_from_outputs: node_latency[%d] = %d for node",
965 n->_idx, _node_latency.at_grow(n->_idx)); 965 n->_idx, _node_latency->at_grow(n->_idx));
966 dump(); 966 dump();
967 } 967 }
968 #endif 968 #endif
969 uint latency=0; 969 uint latency=0;
970 const Node *def = n->is_Proj() ? n->in(0): n; 970 const Node *def = n->is_Proj() ? n->in(0): n;
973 uint l = latency_from_use(n, def, n->fast_out(i)); 973 uint l = latency_from_use(n, def, n->fast_out(i));
974 974
975 if (latency < l) latency = l; 975 if (latency < l) latency = l;
976 } 976 }
977 977
978 _node_latency.at_put_grow(n->_idx, latency); 978 _node_latency->at_put_grow(n->_idx, latency);
979 } 979 }
980 980
981 //------------------------------hoist_to_cheaper_block------------------------- 981 //------------------------------hoist_to_cheaper_block-------------------------
982 // Pick a block for node self, between early and LCA, that is a cheaper 982 // Pick a block for node self, between early and LCA, that is a cheaper
983 // alternative to LCA. 983 // alternative to LCA.
984 Block* PhaseCFG::hoist_to_cheaper_block(Block* LCA, Block* early, Node* self) { 984 Block* PhaseCFG::hoist_to_cheaper_block(Block* LCA, Block* early, Node* self) {
985 const double delta = 1+PROB_UNLIKELY_MAG(4); 985 const double delta = 1+PROB_UNLIKELY_MAG(4);
986 Block* least = LCA; 986 Block* least = LCA;
987 double least_freq = least->_freq; 987 double least_freq = least->_freq;
988 uint target = _node_latency.at_grow(self->_idx); 988 uint target = _node_latency->at_grow(self->_idx);
989 uint start_latency = _node_latency.at_grow(LCA->_nodes[0]->_idx); 989 uint start_latency = _node_latency->at_grow(LCA->_nodes[0]->_idx);
990 uint end_latency = _node_latency.at_grow(LCA->_nodes[LCA->end_idx()]->_idx); 990 uint end_latency = _node_latency->at_grow(LCA->_nodes[LCA->end_idx()]->_idx);
991 bool in_latency = (target <= start_latency); 991 bool in_latency = (target <= start_latency);
992 const Block* root_block = _bbs[_root->_idx]; 992 const Block* root_block = _bbs[_root->_idx];
993 993
994 // Turn off latency scheduling if scheduling is just plain off 994 // Turn off latency scheduling if scheduling is just plain off
995 if (!C->do_scheduling()) 995 if (!C->do_scheduling())
1003 in_latency = true; 1003 in_latency = true;
1004 1004
1005 #ifndef PRODUCT 1005 #ifndef PRODUCT
1006 if (trace_opto_pipelining()) { 1006 if (trace_opto_pipelining()) {
1007 tty->print("# Find cheaper block for latency %d: ", 1007 tty->print("# Find cheaper block for latency %d: ",
1008 _node_latency.at_grow(self->_idx)); 1008 _node_latency->at_grow(self->_idx));
1009 self->dump(); 1009 self->dump();
1010 tty->print_cr("# B%d: start latency for [%4d]=%d, end latency for [%4d]=%d, freq=%g", 1010 tty->print_cr("# B%d: start latency for [%4d]=%d, end latency for [%4d]=%d, freq=%g",
1011 LCA->_pre_order, 1011 LCA->_pre_order,
1012 LCA->_nodes[0]->_idx, 1012 LCA->_nodes[0]->_idx,
1013 start_latency, 1013 start_latency,
1030 1030
1031 // Don't hoist machine instructions to the root basic block 1031 // Don't hoist machine instructions to the root basic block
1032 if (mach && LCA == root_block) 1032 if (mach && LCA == root_block)
1033 break; 1033 break;
1034 1034
1035 uint start_lat = _node_latency.at_grow(LCA->_nodes[0]->_idx); 1035 uint start_lat = _node_latency->at_grow(LCA->_nodes[0]->_idx);
1036 uint end_idx = LCA->end_idx(); 1036 uint end_idx = LCA->end_idx();
1037 uint end_lat = _node_latency.at_grow(LCA->_nodes[end_idx]->_idx); 1037 uint end_lat = _node_latency->at_grow(LCA->_nodes[end_idx]->_idx);
1038 double LCA_freq = LCA->_freq; 1038 double LCA_freq = LCA->_freq;
1039 #ifndef PRODUCT 1039 #ifndef PRODUCT
1040 if (trace_opto_pipelining()) { 1040 if (trace_opto_pipelining()) {
1041 tty->print_cr("# B%d: start latency for [%4d]=%d, end latency for [%4d]=%d, freq=%g", 1041 tty->print_cr("# B%d: start latency for [%4d]=%d, end latency for [%4d]=%d, freq=%g",
1042 LCA->_pre_order, LCA->_nodes[0]->_idx, start_lat, end_idx, end_lat, LCA_freq); 1042 LCA->_pre_order, LCA->_nodes[0]->_idx, start_lat, end_idx, end_lat, LCA_freq);
1071 #ifndef PRODUCT 1071 #ifndef PRODUCT
1072 if (trace_opto_pipelining()) { 1072 if (trace_opto_pipelining()) {
1073 tty->print_cr("# Change latency for [%4d] from %d to %d", self->_idx, target, end_latency); 1073 tty->print_cr("# Change latency for [%4d] from %d to %d", self->_idx, target, end_latency);
1074 } 1074 }
1075 #endif 1075 #endif
1076 _node_latency.at_put_grow(self->_idx, end_latency); 1076 _node_latency->at_put_grow(self->_idx, end_latency);
1077 partial_latency_of_defs(self); 1077 partial_latency_of_defs(self);
1078 } 1078 }
1079 1079
1080 return least; 1080 return least;
1081 } 1081 }
1253 proj_list.push(_root); // Add real root as another root 1253 proj_list.push(_root); // Add real root as another root
1254 proj_list.pop(); 1254 proj_list.pop();
1255 1255
1256 // Compute the latency information (via backwards walk) for all the 1256 // Compute the latency information (via backwards walk) for all the
1257 // instructions in the graph 1257 // instructions in the graph
1258 GrowableArray<uint> node_latency; 1258 _node_latency = new GrowableArray<uint>(); // resource_area allocation
1259 _node_latency = node_latency;
1260 1259
1261 if( C->do_scheduling() ) 1260 if( C->do_scheduling() )
1262 ComputeLatenciesBackwards(visited, stack); 1261 ComputeLatenciesBackwards(visited, stack);
1263 1262
1264 // Now schedule all codes as LATE as possible. This is the LCA in the 1263 // Now schedule all codes as LATE as possible. This is the LCA in the
1339 for (uint i = 0; i < _num_blocks; i++) { 1338 for (uint i = 0; i < _num_blocks; i++) {
1340 _blocks[i]->dump(); 1339 _blocks[i]->dump();
1341 } 1340 }
1342 } 1341 }
1343 #endif 1342 #endif
1343 // Dead.
1344 _node_latency = (GrowableArray<uint> *)0xdeadbeef;
1344 } 1345 }
1345 1346
1346 1347
1347 //------------------------------Estimate_Block_Frequency----------------------- 1348 //------------------------------Estimate_Block_Frequency-----------------------
1348 // Estimate block frequencies based on IfNode probabilities. 1349 // Estimate block frequencies based on IfNode probabilities.