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;
|