--- a/hotspot/src/share/vm/ci/bcEscapeAnalyzer.cpp Tue Mar 11 11:25:13 2008 -0700
+++ b/hotspot/src/share/vm/ci/bcEscapeAnalyzer.cpp Tue Mar 11 19:00:38 2008 -0700
@@ -104,7 +104,7 @@
};
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);
}
@@ -112,10 +112,9 @@
_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;
}
@@ -126,7 +125,7 @@
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;
}
@@ -134,12 +133,13 @@
}
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);
}
@@ -155,6 +155,17 @@
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) {
@@ -164,6 +175,40 @@
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;
@@ -197,6 +242,7 @@
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;
}
@@ -224,6 +270,11 @@
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)) {
@@ -233,6 +284,7 @@
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) {
@@ -250,8 +302,10 @@
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
}
}
@@ -421,6 +475,7 @@
state.spop();
ArgumentMap arr = state.apop();
set_method_escape(arr);
+ set_modified(arr, OFFSET_ANY, type2size[T_INT]*HeapWordSize);
break;
}
case Bytecodes::_lastore:
@@ -430,6 +485,7 @@
state.spop();
ArgumentMap arr = state.apop();
set_method_escape(arr);
+ set_modified(arr, OFFSET_ANY, type2size[T_LONG]*HeapWordSize);
break;
}
case Bytecodes::_aastore:
@@ -437,6 +493,7 @@
set_global_escape(state.apop());
state.spop();
ArgumentMap arr = state.apop();
+ set_modified(arr, OFFSET_ANY, type2size[T_OBJECT]*HeapWordSize);
break;
}
case Bytecodes::_pop:
@@ -762,6 +819,7 @@
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;
@@ -872,7 +930,7 @@
}
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
@@ -916,6 +974,7 @@
}
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]);
@@ -933,7 +992,7 @@
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;
@@ -961,33 +1020,35 @@
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;
}
@@ -997,6 +1058,7 @@
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 {
@@ -1053,6 +1115,7 @@
vmIntrinsics::ID iid = method()->intrinsic_id();
if (iid == vmIntrinsics::_getClass ||
+ iid == vmIntrinsics::_fillInStackTrace ||
iid == vmIntrinsics::_hashCode)
return iid;
else
@@ -1060,12 +1123,16 @@
}
bool BCEscapeAnalyzer::compute_escape_for_intrinsic(vmIntrinsics::ID iid) {
- ArgumentMap empty;
- empty.clear();
+ ArgumentMap arg;
+ 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;
@@ -1109,15 +1176,21 @@
_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();
@@ -1126,6 +1199,7 @@
_return_local = false;
_return_allocated = false;
_allocated_escapes = true;
+ _unknown_modified = true;
}
@@ -1205,8 +1279,17 @@
} 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();
@@ -1228,6 +1311,7 @@
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);
@@ -1244,6 +1328,7 @@
_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);
@@ -1261,6 +1346,12 @@
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
@@ -1281,6 +1372,7 @@
, _return_local(false)
, _return_allocated(false)
, _allocated_escapes(false)
+ , _unknown_modified(false)
, _dependencies()
, _parent(parent)
, _level(parent == NULL ? 0 : parent->level() + 1) {
@@ -1290,6 +1382,8 @@
_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;