src/share/vm/ci/bcEscapeAnalyzer.cpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File 7112478 Sdiff src/share/vm/ci

src/share/vm/ci/bcEscapeAnalyzer.cpp

Print this page




 133     return true;
 134   for (int i = 0; i < _arg_size; i++) {
 135     if (vars.contains(i) && _arg_stack.test(i))
 136       return true;
 137   }
 138   return false;
 139 }
 140 
 141 void BCEscapeAnalyzer::clear_bits(ArgumentMap vars, VectorSet &bm) {
 142   for (int i = 0; i < _arg_size; i++) {
 143     if (vars.contains(i)) {
 144       bm >>= i;
 145     }
 146   }
 147 }
 148 
 149 void BCEscapeAnalyzer::set_method_escape(ArgumentMap vars) {
 150   clear_bits(vars, _arg_local);
 151 }
 152 
 153 void BCEscapeAnalyzer::set_global_escape(ArgumentMap vars) {
 154   clear_bits(vars, _arg_local);
 155   clear_bits(vars, _arg_stack);
 156   if (vars.contains_allocated())
 157     _allocated_escapes = true;












 158 }
 159 
 160 void BCEscapeAnalyzer::set_dirty(ArgumentMap vars) {
 161   clear_bits(vars, _dirty);
 162 }
 163 
 164 void BCEscapeAnalyzer::set_modified(ArgumentMap vars, int offs, int size) {
 165 
 166   for (int i = 0; i < _arg_size; i++) {
 167     if (vars.contains(i)) {
 168       set_arg_modified(i, offs, size);
 169     }
 170   }
 171   if (vars.contains_unknown())
 172     _unknown_modified = true;
 173 }
 174 
 175 bool BCEscapeAnalyzer::is_recursive_call(ciMethod* callee) {
 176   for (BCEscapeAnalyzer* scope = this; scope != NULL; scope = scope->_parent) {
 177     if (scope->method() == callee) {


 982     // arguments in the source state which are not in the dest state
 983     // as global escape.
 984     // Future refinement:  we only need to mark these variable to the
 985     // maximum escape of any variables in dest state
 986     assert(d_state->_stack_height == s_state->_stack_height, "computed stack heights must match");
 987     ArgumentMap extra_vars;
 988     for (int i = 0; i < nlocals; i++) {
 989       ArgumentMap t;
 990       t = s_state->_vars[i];
 991       t.set_difference(d_state->_vars[i]);
 992       extra_vars.set_union(t);
 993     }
 994     for (int i = 0; i < s_state->_stack_height; i++) {
 995       ArgumentMap t;
 996       //extra_vars |= !d_state->_vars[i] & s_state->_vars[i];
 997       t.clear();
 998       t = s_state->_stack[i];
 999       t.set_difference(d_state->_stack[i]);
1000       extra_vars.set_union(t);
1001     }
1002     set_global_escape(extra_vars);
1003   }
1004 }
1005 
1006 void BCEscapeAnalyzer::iterate_blocks(Arena *arena) {
1007   int numblocks = _methodBlocks->num_blocks();
1008   int stkSize   = _method->max_stack();
1009   int numLocals = _method->max_locals();
1010   StateInfo state;
1011 
1012   int datacount = (numblocks + 1) * (stkSize + numLocals);
1013   int datasize = datacount * sizeof(ArgumentMap);
1014   StateInfo *blockstates = (StateInfo *) arena->Amalloc(numblocks * sizeof(StateInfo));
1015   ArgumentMap *statedata  = (ArgumentMap *) arena->Amalloc(datasize);
1016   for (int i = 0; i < datacount; i++) ::new ((void*)&statedata[i]) ArgumentMap();
1017   ArgumentMap *dp = statedata;
1018   state._vars = dp;
1019   dp += numLocals;
1020   state._stack = dp;
1021   dp += stkSize;
1022   state._initialized = false;




 133     return true;
 134   for (int i = 0; i < _arg_size; i++) {
 135     if (vars.contains(i) && _arg_stack.test(i))
 136       return true;
 137   }
 138   return false;
 139 }
 140 
 141 void BCEscapeAnalyzer::clear_bits(ArgumentMap vars, VectorSet &bm) {
 142   for (int i = 0; i < _arg_size; i++) {
 143     if (vars.contains(i)) {
 144       bm >>= i;
 145     }
 146   }
 147 }
 148 
 149 void BCEscapeAnalyzer::set_method_escape(ArgumentMap vars) {
 150   clear_bits(vars, _arg_local);
 151 }
 152 
 153 void BCEscapeAnalyzer::set_global_escape(ArgumentMap vars, bool merge) {
 154   clear_bits(vars, _arg_local);
 155   clear_bits(vars, _arg_stack);
 156   if (vars.contains_allocated())
 157     _allocated_escapes = true;
 158 
 159   if (merge && !vars.is_empty()) {
 160     // Merge new state into already processed block.
 161     // New state is not taken into account and
 162     // it may invalidate set_returned() result.
 163     if (vars.contains_unknown() || vars.contains_allocated()) {
 164       _return_local = false;
 165     }
 166     if (vars.contains_unknown() || vars.contains_vars()) {
 167       _return_allocated = false;
 168     }
 169   }
 170 }
 171 
 172 void BCEscapeAnalyzer::set_dirty(ArgumentMap vars) {
 173   clear_bits(vars, _dirty);
 174 }
 175 
 176 void BCEscapeAnalyzer::set_modified(ArgumentMap vars, int offs, int size) {
 177 
 178   for (int i = 0; i < _arg_size; i++) {
 179     if (vars.contains(i)) {
 180       set_arg_modified(i, offs, size);
 181     }
 182   }
 183   if (vars.contains_unknown())
 184     _unknown_modified = true;
 185 }
 186 
 187 bool BCEscapeAnalyzer::is_recursive_call(ciMethod* callee) {
 188   for (BCEscapeAnalyzer* scope = this; scope != NULL; scope = scope->_parent) {
 189     if (scope->method() == callee) {


 994     // arguments in the source state which are not in the dest state
 995     // as global escape.
 996     // Future refinement:  we only need to mark these variable to the
 997     // maximum escape of any variables in dest state
 998     assert(d_state->_stack_height == s_state->_stack_height, "computed stack heights must match");
 999     ArgumentMap extra_vars;
1000     for (int i = 0; i < nlocals; i++) {
1001       ArgumentMap t;
1002       t = s_state->_vars[i];
1003       t.set_difference(d_state->_vars[i]);
1004       extra_vars.set_union(t);
1005     }
1006     for (int i = 0; i < s_state->_stack_height; i++) {
1007       ArgumentMap t;
1008       //extra_vars |= !d_state->_vars[i] & s_state->_vars[i];
1009       t.clear();
1010       t = s_state->_stack[i];
1011       t.set_difference(d_state->_stack[i]);
1012       extra_vars.set_union(t);
1013     }
1014     set_global_escape(extra_vars, true);
1015   }
1016 }
1017 
1018 void BCEscapeAnalyzer::iterate_blocks(Arena *arena) {
1019   int numblocks = _methodBlocks->num_blocks();
1020   int stkSize   = _method->max_stack();
1021   int numLocals = _method->max_locals();
1022   StateInfo state;
1023 
1024   int datacount = (numblocks + 1) * (stkSize + numLocals);
1025   int datasize = datacount * sizeof(ArgumentMap);
1026   StateInfo *blockstates = (StateInfo *) arena->Amalloc(numblocks * sizeof(StateInfo));
1027   ArgumentMap *statedata  = (ArgumentMap *) arena->Amalloc(datasize);
1028   for (int i = 0; i < datacount; i++) ::new ((void*)&statedata[i]) ArgumentMap();
1029   ArgumentMap *dp = statedata;
1030   state._vars = dp;
1031   dp += numLocals;
1032   state._stack = dp;
1033   dp += stkSize;
1034   state._initialized = false;


src/share/vm/ci/bcEscapeAnalyzer.cpp
Index Unified diffs Context diffs Sdiffs Wdiffs Patch New Old Previous File Next File