1094 }
1095 }
1096
1097 void frame::nmethods_do(CodeBlobClosure* cf) {
1098 if (_cb != NULL && _cb->is_nmethod()) {
1099 cf->do_code_blob(_cb);
1100 }
1101 }
1102
1103
1104 // call f() on the interpreted Method*s in the stack.
1105 // Have to walk the entire code cache for the compiled frames Yuck.
1106 void frame::metadata_do(void f(Metadata*)) {
1107 if (is_interpreted_frame()) {
1108 Method* m = this->interpreter_frame_method();
1109 assert(m != NULL, "expecting a method in this frame");
1110 f(m);
1111 }
1112 }
1113
1114 # ifdef ENABLE_ZAP_DEAD_LOCALS
1115
1116 void frame::CheckValueClosure::do_oop(oop* p) {
1117 if (CheckOopishValues && Universe::heap()->is_in_reserved(*p)) {
1118 warning("value @ " INTPTR_FORMAT " looks oopish (" INTPTR_FORMAT ") (thread = " INTPTR_FORMAT ")", p, (address)*p, Thread::current());
1119 }
1120 }
1121 frame::CheckValueClosure frame::_check_value;
1122
1123
1124 void frame::CheckOopClosure::do_oop(oop* p) {
1125 if (*p != NULL && !(*p)->is_oop()) {
1126 warning("value @ " INTPTR_FORMAT " should be an oop (" INTPTR_FORMAT ") (thread = " INTPTR_FORMAT ")", p, (address)*p, Thread::current());
1127 }
1128 }
1129 frame::CheckOopClosure frame::_check_oop;
1130
1131 void frame::check_derived_oop(oop* base, oop* derived) {
1132 _check_oop.do_oop(base);
1133 }
1134
1135
1136 void frame::ZapDeadClosure::do_oop(oop* p) {
1137 if (TraceZapDeadLocals) tty->print_cr("zapping @ " INTPTR_FORMAT " containing " INTPTR_FORMAT, p, (address)*p);
1138 *p = cast_to_oop<intptr_t>(0xbabebabe);
1139 }
1140 frame::ZapDeadClosure frame::_zap_dead;
1141
1142 void frame::zap_dead_locals(JavaThread* thread, const RegisterMap* map) {
1143 assert(thread == Thread::current(), "need to synchronize to do this to another thread");
1144 // Tracing - part 1
1145 if (TraceZapDeadLocals) {
1146 ResourceMark rm(thread);
1147 tty->print_cr("--------------------------------------------------------------------------------");
1148 tty->print("Zapping dead locals in ");
1149 print_on(tty);
1150 tty->cr();
1151 }
1152 // Zapping
1153 if (is_entry_frame ()) zap_dead_entry_locals (thread, map);
1154 else if (is_interpreted_frame()) zap_dead_interpreted_locals(thread, map);
1155 else if (is_compiled_frame()) zap_dead_compiled_locals (thread, map);
1156
1157 else
1158 // could be is_runtime_frame
1159 // so remove error: ShouldNotReachHere();
1160 ;
1161 // Tracing - part 2
1162 if (TraceZapDeadLocals) {
1163 tty->cr();
1164 }
1165 }
1166
1167
1168 void frame::zap_dead_interpreted_locals(JavaThread *thread, const RegisterMap* map) {
1169 // get current interpreter 'pc'
1170 assert(is_interpreted_frame(), "Not an interpreted frame");
1171 Method* m = interpreter_frame_method();
1172 int bci = interpreter_frame_bci();
1173
1174 int max_locals = m->is_native() ? m->size_of_parameters() : m->max_locals();
1175
1176 // process dynamic part
1177 InterpreterFrameClosure value_blk(this, max_locals, m->max_stack(),
1178 &_check_value);
1179 InterpreterFrameClosure oop_blk(this, max_locals, m->max_stack(),
1180 &_check_oop );
1181 InterpreterFrameClosure dead_blk(this, max_locals, m->max_stack(),
1182 &_zap_dead );
1183
1184 // get frame map
1185 InterpreterOopMap mask;
1186 m->mask_for(bci, &mask);
1187 mask.iterate_all( &oop_blk, &value_blk, &dead_blk);
1188 }
1189
1190
1191 void frame::zap_dead_compiled_locals(JavaThread* thread, const RegisterMap* reg_map) {
1192
1193 ResourceMark rm(thread);
1194 assert(_cb != NULL, "sanity check");
1195 if (_cb->oop_maps() != NULL) {
1196 OopMapSet::all_do(this, reg_map, &_check_oop, check_derived_oop, &_check_value);
1197 }
1198 }
1199
1200
1201 void frame::zap_dead_entry_locals(JavaThread*, const RegisterMap*) {
1202 if (TraceZapDeadLocals) warning("frame::zap_dead_entry_locals unimplemented");
1203 }
1204
1205
1206 void frame::zap_dead_deoptimized_locals(JavaThread*, const RegisterMap*) {
1207 if (TraceZapDeadLocals) warning("frame::zap_dead_deoptimized_locals unimplemented");
1208 }
1209
1210 # endif // ENABLE_ZAP_DEAD_LOCALS
1211
1212 void frame::verify(const RegisterMap* map) {
1213 // for now make sure receiver type is correct
1214 if (is_interpreted_frame()) {
1215 Method* method = interpreter_frame_method();
1216 guarantee(method->is_method(), "method is wrong in frame::verify");
1217 if (!method->is_static()) {
1218 // fetch the receiver
1219 oop* p = (oop*) interpreter_frame_local_at(0);
1220 // make sure we have the right receiver type
1221 }
1222 }
1223 COMPILER2_PRESENT(assert(DerivedPointerTable::is_empty(), "must be empty before verify");)
1224 oops_do_internal(&VerifyOopClosure::verify_oop, NULL, NULL, (RegisterMap*)map, false);
1225 }
1226
1227
1228 #ifdef ASSERT
1229 bool frame::verify_return_pc(address x) {
1230 if (StubRoutines::returns_to_call_stub(x)) {
1231 return true;
|
1094 }
1095 }
1096
1097 void frame::nmethods_do(CodeBlobClosure* cf) {
1098 if (_cb != NULL && _cb->is_nmethod()) {
1099 cf->do_code_blob(_cb);
1100 }
1101 }
1102
1103
1104 // call f() on the interpreted Method*s in the stack.
1105 // Have to walk the entire code cache for the compiled frames Yuck.
1106 void frame::metadata_do(void f(Metadata*)) {
1107 if (is_interpreted_frame()) {
1108 Method* m = this->interpreter_frame_method();
1109 assert(m != NULL, "expecting a method in this frame");
1110 f(m);
1111 }
1112 }
1113
1114 void frame::verify(const RegisterMap* map) {
1115 // for now make sure receiver type is correct
1116 if (is_interpreted_frame()) {
1117 Method* method = interpreter_frame_method();
1118 guarantee(method->is_method(), "method is wrong in frame::verify");
1119 if (!method->is_static()) {
1120 // fetch the receiver
1121 oop* p = (oop*) interpreter_frame_local_at(0);
1122 // make sure we have the right receiver type
1123 }
1124 }
1125 COMPILER2_PRESENT(assert(DerivedPointerTable::is_empty(), "must be empty before verify");)
1126 oops_do_internal(&VerifyOopClosure::verify_oop, NULL, NULL, (RegisterMap*)map, false);
1127 }
1128
1129
1130 #ifdef ASSERT
1131 bool frame::verify_return_pc(address x) {
1132 if (StubRoutines::returns_to_call_stub(x)) {
1133 return true;
|