jdk-sandbox: comparison hotspot/src/share/vm/ci/bcEscapeAnalyzer.cpp

equal deleted inserted replaced

-:c646ef2f5d58
+:a0e996680b05
 void lpush()           { spush(); spush(); }
 };
 void BCEscapeAnalyzer::set_returned(ArgumentMap vars) {
-for (int i = 0; i <= _arg_size; i++) {
+for (int i = 0; i < _arg_size; i++) {
 if (vars.contains(i))
 _arg_returned.set_bit(i);
 }
 _return_local = _return_local && !(vars.contains_unknown() || vars.contains_allocated());
 _return_allocated = _return_allocated && vars.contains_allocated() && !(vars.contains_unknown() || vars.contains_vars());
 }
 // return true if any element of vars is an argument
 bool BCEscapeAnalyzer::is_argument(ArgumentMap vars) {
-for (int i = 0; i <= _arg_size; i++) {
+for (int i = 0; i < _arg_size; i++) {
 if (vars.contains(i))
 return true;
 }
 return false;
 }
 // return true if any element of vars is an arg_stack argument
 bool BCEscapeAnalyzer::is_arg_stack(ArgumentMap vars){
 if (_conservative)
 return true;
-for (int i = 0; i <= _arg_size; i++) {
+for (int i = 0; i < _arg_size; i++) {
 if (vars.contains(i) && _arg_stack.at(i))
 return true;
 }
 return false;
 }
 void BCEscapeAnalyzer::clear_bits(ArgumentMap vars, BitMap &bm) {
-for (int i = 0; i <= _arg_size; i++) {
+for (int i = 0; i < _arg_size; i++) {
 if (vars.contains(i)) {
 bm.clear_bit(i);
 }
 }
 }
 void BCEscapeAnalyzer::set_method_escape(ArgumentMap vars) {
 clear_bits(vars, _arg_local);
 }
 void BCEscapeAnalyzer::set_global_escape(ArgumentMap vars) {
 void BCEscapeAnalyzer::set_dirty(ArgumentMap vars) {
 clear_bits(vars, _dirty);
 }
+void BCEscapeAnalyzer::set_modified(ArgumentMap vars, int offs, int size) {
+for (int i = 0; i < _arg_size; i++) {
+if (vars.contains(i)) {
+set_arg_modified(i, offs, size);
+}
+}
+if (vars.contains_unknown())
+_unknown_modified = true;
+}
 bool BCEscapeAnalyzer::is_recursive_call(ciMethod* callee) {
 for (BCEscapeAnalyzer* scope = this; scope != NULL; scope = scope->_parent) {
 if (scope->method() == callee) {
 return true;
 }
 }
 return false;
+}
+bool BCEscapeAnalyzer::is_arg_modified(int arg, int offset, int size_in_bytes) {
+if (offset == OFFSET_ANY)
+return _arg_modified[arg] != 0;
+assert(arg >= 0 && arg < _arg_size, "must be an argument.");
+bool modified = false;
+int l = offset / HeapWordSize;
+int h = round_to(offset + size_in_bytes, HeapWordSize) / HeapWordSize;
+if (l > ARG_OFFSET_MAX)
+l = ARG_OFFSET_MAX;
+if (h > ARG_OFFSET_MAX+1)
+h = ARG_OFFSET_MAX + 1;
+for (int i = l; i < h; i++) {
+modified = modified || (_arg_modified[arg] & (1 << i)) != 0;
+}
+return modified;
+}
+void BCEscapeAnalyzer::set_arg_modified(int arg, int offset, int size_in_bytes) {
+if (offset == OFFSET_ANY) {
+_arg_modified[arg] =  (uint) -1;
+return;
+}
+assert(arg >= 0 && arg < _arg_size, "must be an argument.");
+int l = offset / HeapWordSize;
+int h = round_to(offset + size_in_bytes, HeapWordSize) / HeapWordSize;
+if (l > ARG_OFFSET_MAX)
+l = ARG_OFFSET_MAX;
+if (h > ARG_OFFSET_MAX+1)
+h = ARG_OFFSET_MAX + 1;
+for (int i = l; i < h; i++) {
+_arg_modified[arg] |= (1 << i);
+}
 }
 void BCEscapeAnalyzer::invoke(StateInfo &state, Bytecodes::Code code, ciMethod* target, ciKlass* holder) {
 int i;
 if (skip_callee) {
 TRACE_BCEA(3, tty->print_cr("[EA] skipping method %s::%s", holder->name()->as_utf8(), target->name()->as_utf8()));
 for (i = 0; i < arg_size; i++) {
 set_method_escape(state.raw_pop());
 }
+_unknown_modified = true;  // assume the worst since we don't analyze the called method
 return;
 }
 // determine actual method (use CHA if necessary)
 ciMethod* inline_target = NULL;
 bool must_record_dependencies = false;
 for (i = arg_size - 1; i >= 0; i--) {
 ArgumentMap arg = state.raw_pop();
 if (!is_argument(arg))
 continue;
+for (int j = 0; j < _arg_size; j++) {
+if (arg.contains(j)) {
+_arg_modified[j] |= analyzer._arg_modified[i];
+}
+}
 if (!is_arg_stack(arg)) {
 // arguments have already been recognized as escaping
 } else if (analyzer.is_arg_stack(i) && !analyzer.is_arg_returned(i)) {
 set_method_escape(arg);
 must_record_dependencies = true;
 } else {
 set_global_escape(arg);
 }
 }
+_unknown_modified = _unknown_modified || analyzer.has_non_arg_side_affects();
 // record dependencies if at least one parameter retained stack-allocatable
 if (must_record_dependencies) {
 if (code == Bytecodes::_invokeinterface || code == Bytecodes::_invokevirtual && !target->is_final_method()) {
 _dependencies.append(actual_recv);
 // conservatively mark all actual parameters as escaping globally
 for (i = 0; i < arg_size; i++) {
 ArgumentMap arg = state.raw_pop();
 if (!is_argument(arg))
 continue;
+set_modified(arg, OFFSET_ANY, type2size[T_INT]*HeapWordSize);
 set_global_escape(arg);
 }
+_unknown_modified = true;  // assume the worst since we don't know the called method
 }
 }
 bool BCEscapeAnalyzer::contains(uint arg_set1, uint arg_set2) {
 return ((~arg_set1) | arg_set2) == 0;
 {
 state.spop();
 state.spop();
 ArgumentMap arr = state.apop();
 set_method_escape(arr);
+set_modified(arr, OFFSET_ANY, type2size[T_INT]*HeapWordSize);
 break;
 }
 case Bytecodes::_lastore:
 case Bytecodes::_dastore:
 {
 state.lpop();
 state.spop();
 ArgumentMap arr = state.apop();
 set_method_escape(arr);
+set_modified(arr, OFFSET_ANY, type2size[T_LONG]*HeapWordSize);
 break;
 }
 case Bytecodes::_aastore:
 {
 set_global_escape(state.apop());
 state.spop();
 ArgumentMap arr = state.apop();
+set_modified(arr, OFFSET_ANY, type2size[T_OBJECT]*HeapWordSize);
 break;
 }
 case Bytecodes::_pop:
 state.raw_pop();
 break;
 state.lpop();
 }
 if (s.cur_bc() != Bytecodes::_putstatic) {
 ArgumentMap p = state.apop();
 set_method_escape(p);
+set_modified(p, will_link ? field->offset() : OFFSET_ANY, type2size[field_type]*HeapWordSize);
 }
 }
 break;
 case Bytecodes::_invokevirtual:
 case Bytecodes::_invokespecial:
 }
 }
 }
 void BCEscapeAnalyzer::merge_block_states(StateInfo *blockstates, ciBlock *dest, StateInfo *s_state) {
-StateInfo *d_state = blockstates+dest->index();
+StateInfo *d_state = blockstates + dest->index();
 int nlocals = _method->max_locals();
 // exceptions may cause transfer of control to handlers in the middle of a
 // block, so we don't merge the incoming state of exception handlers
 if (dest->is_handler())
 t.set_difference(d_state->_vars[i]);
 extra_vars.set_union(t);
 }
 for (int i = 0; i < s_state->_stack_height; i++) {
 ArgumentMap t;
+//extra_vars |= !d_state->_vars[i] & s_state->_vars[i];
 t.clear();
 t = s_state->_stack[i];
 t.set_difference(d_state->_stack[i]);
 extra_vars.set_union(t);
 }
 int numLocals = _method->max_locals();
 StateInfo state;
 int datacount = (numblocks + 1) * (stkSize + numLocals);
 int datasize = datacount * sizeof(ArgumentMap);
-StateInfo *blockstates = (StateInfo *) arena->Amalloc(_methodBlocks->num_blocks() * sizeof(StateInfo));
+StateInfo *blockstates = (StateInfo *) arena->Amalloc(numblocks * sizeof(StateInfo));
 ArgumentMap *statedata  = (ArgumentMap *) arena->Amalloc(datasize);
 for (int i = 0; i < datacount; i++) ::new ((void*)&statedata[i]) ArgumentMap();
 ArgumentMap *dp = statedata;
 state._vars = dp;
 dp += numLocals;
 // initialize block 0 state from method signature
 ArgumentMap allVars;   // all oop arguments to method
 ciSignature* sig = method()->signature();
 int j = 0;
+ciBlock* first_blk = _methodBlocks->block_containing(0);
+int fb_i = first_blk->index();
 if (!method()->is_static()) {
 // record information for "this"
-blockstates[0]._vars[j].set(j);
+blockstates[fb_i]._vars[j].set(j);
 allVars.add(j);
 j++;
 }
 for (int i = 0; i < sig->count(); i++) {
 ciType* t = sig->type_at(i);
 if (!t->is_primitive_type()) {
-blockstates[0]._vars[j].set(j);
+blockstates[fb_i]._vars[j].set(j);
 allVars.add(j);
 }
 j += t->size();
 }
-blockstates[0]._initialized = true;
+blockstates[fb_i]._initialized = true;
 assert(j == _arg_size, "just checking");
 ArgumentMap unknown_map;
 unknown_map.add_unknown();
-worklist.push(_methodBlocks->block_containing(0));
+worklist.push(first_blk);
 while(worklist.length() > 0) {
 ciBlock *blk = worklist.pop();
-StateInfo *blkState = blockstates+blk->index();
+StateInfo *blkState = blockstates + blk->index();
 if (blk->is_handler() || blk->is_ret_target()) {
 // for an exception handler or a target of a ret instruction, we assume the worst case,
-// that any variable or stack slot could contain any argument
+// that any variable could contain any argument
 for (int i = 0; i < numLocals; i++) {
 state._vars[i] = allVars;
 }
 if (blk->is_handler()) {
 state._stack_height = 1;
 } else {
 state._stack_height = blkState->_stack_height;
 }
 for (int i = 0; i < state._stack_height; i++) {
+// ??? should this be unknown_map ???
 state._stack[i] = allVars;
 }
 } else {
 for (int i = 0; i < numLocals; i++) {
 state._vars[i] = blkState->_vars[i];
 vmIntrinsics::ID BCEscapeAnalyzer::known_intrinsic() {
 vmIntrinsics::ID iid = method()->intrinsic_id();
 if (iid == vmIntrinsics::_getClass ||
+iid ==  vmIntrinsics::_fillInStackTrace ||
 iid == vmIntrinsics::_hashCode)
 return iid;
 else
 return vmIntrinsics::_none;
 }
 bool BCEscapeAnalyzer::compute_escape_for_intrinsic(vmIntrinsics::ID iid) {
-ArgumentMap empty;
+ArgumentMap arg;
-empty.clear();
+arg.clear();
 switch (iid) {
 case vmIntrinsics::_getClass:
 _return_local = false;
+break;
+case vmIntrinsics::_fillInStackTrace:
+arg.set(0); // 'this'
+set_returned(arg);
 break;
 case vmIntrinsics::_hashCode:
 // initialized state is correct
 break;
 default:
 } else {
 _return_local = true;
 _return_allocated = true;
 }
 _allocated_escapes = false;
+_unknown_modified = false;
 }
 void BCEscapeAnalyzer::clear_escape_info() {
 ciSignature* sig = method()->signature();
 int arg_count = sig->count();
 ArgumentMap var;
+if (!method()->is_static()) {
+arg_count++;  // allow for "this"
+}
 for (int i = 0; i < arg_count; i++) {
+set_arg_modified(i, OFFSET_ANY, 4);
 var.clear();
 var.set(i);
+set_modified(var, OFFSET_ANY, 4);
 set_global_escape(var);
 }
 _arg_local.clear();
 _arg_stack.clear();
 _arg_returned.clear();
 _return_local = false;
 _return_allocated = false;
 _allocated_escapes = true;
+_unknown_modified = true;
 }
 void BCEscapeAnalyzer::compute_escape_info() {
 int i;
 } else if (is_return_allocated()) {
 tty->print_cr("     allocated return values");
 } else {
 tty->print_cr("     non-local return values");
 }
+tty->print("     modified args: ");
+for (int i = 0; i < _arg_size; i++) {
+if (_arg_modified[i] == 0)
+tty->print("    0");
+else
+tty->print("    0x%x", _arg_modified[i]);
+}
 tty->cr();
 tty->print("     flags: ");
+if (_unknown_modified)
+tty->print(" unknown_modified");
 if (_return_allocated)
 tty->print(" return_allocated");
 tty->cr();
 }
 methodData()->set_arg_stack(i);
 }
 if (_arg_returned.at(i)) {
 methodData()->set_arg_returned(i);
 }
+methodData()->set_arg_modified(i, _arg_modified[i]);
 }
 if (_return_local) {
 methodData()->set_eflag(methodDataOopDesc::return_local);
 }
 methodData()->set_eflag(methodDataOopDesc::estimated);
 // read escape information from method descriptor
 for (int i = 0; i < _arg_size; i++) {
 _arg_local.at_put(i, methodData()->is_arg_local(i));
 _arg_stack.at_put(i, methodData()->is_arg_stack(i));
 _arg_returned.at_put(i, methodData()->is_arg_returned(i));
+_arg_modified[i] = methodData()->arg_modified(i);
 }
 _return_local = methodData()->eflag_set(methodDataOopDesc::return_local);
 // dump result of loaded escape information
 #ifndef PRODUCT
 _arg_returned.print_on(tty);
 } else {
 tty->print_cr("     non-local return values");
 }
 tty->print("     modified args: ");
+for (int i = 0; i < _arg_size; i++) {
+if (_arg_modified[i] == 0)
+tty->print("    0");
+else
+tty->print("    0x%x", _arg_modified[i]);
+}
 tty->cr();
 }
 #endif
 }
 , _arg_returned(_arg_size)
 , _dirty(_arg_size)
 , _return_local(false)
 , _return_allocated(false)
 , _allocated_escapes(false)
+, _unknown_modified(false)
 , _dependencies()
 , _parent(parent)
 , _level(parent == NULL ? 0 : parent->level() + 1) {
 if (!_conservative) {
 _arg_local.clear();
 _arg_stack.clear();
 _arg_returned.clear();
 _dirty.clear();
 Arena* arena = CURRENT_ENV->arena();
+_arg_modified = (uint *) arena->Amalloc(_arg_size * sizeof(uint));
+Copy::zero_to_bytes(_arg_modified, _arg_size * sizeof(uint));
 if (methodData() == NULL)
 return;
 bool printit = _method->should_print_assembly();
 if (methodData()->has_escape_info()) {

changeset 218	a0e996680b05
parent 1	489c9b5090e2
child 251	cb2e73f71205