51 _saw_free_extra_data(false),
52 // Initialize the escape information (to "don't know.");
53 _eflags(0), _arg_local(0), _arg_stack(0), _arg_returned(0),
54 _invocation_counter(0),
55 _orig() {}
56
57 // Check for entries that reference an unloaded method
58 class PrepareExtraDataClosure : public CleanExtraDataClosure {
59 MethodData* _mdo;
60 SafepointStateTracker _safepoint_tracker;
61 GrowableArray<Method*> _uncached_methods;
62
63 public:
64 PrepareExtraDataClosure(MethodData* mdo)
65 : _mdo(mdo),
66 _safepoint_tracker(SafepointSynchronize::safepoint_state_tracker()),
67 _uncached_methods()
68 { }
69
70 bool is_live(Method* m) {
71 if (!m->method_holder()->is_loader_alive()) {
72 return false;
73 }
74 if (CURRENT_ENV->cached_metadata(m) == nullptr) {
75 // Uncached entries need to be pre-populated.
76 _uncached_methods.append(m);
77 }
78 return true;
79 }
80
81 bool has_safepointed() {
82 return _safepoint_tracker.safepoint_state_changed();
83 }
84
85 bool finish() {
86 if (_uncached_methods.length() == 0) {
87 // Preparation finished iff all Methods* were already cached.
88 return true;
89 }
90 // We are currently holding the extra_data_lock and ensuring
91 // no safepoint breaks the lock.
286 _invocation_counter = 1;
287 }
288
289 _state = mdo->is_mature() ? mature_state : immature_state;
290 _eflags = mdo->eflags();
291 _arg_local = mdo->arg_local();
292 _arg_stack = mdo->arg_stack();
293 _arg_returned = mdo->arg_returned();
294 if (ReplayCompiles) {
295 ciReplay::initialize(this);
296 if (is_empty()) {
297 return false;
298 }
299 }
300 return true;
301 }
302
303 void ciReceiverTypeData::translate_receiver_data_from(const ProfileData* data) {
304 for (uint row = 0; row < row_limit(); row++) {
305 Klass* k = data->as_ReceiverTypeData()->receiver(row);
306 if (k != nullptr) {
307 if (k->is_loader_alive()) {
308 ciKlass* klass = CURRENT_ENV->get_klass(k);
309 set_receiver(row, klass);
310 } else {
311 // With concurrent class unloading, the MDO could have stale metadata; override it
312 clear_row(row);
313 }
314 } else {
315 set_receiver(row, nullptr);
316 }
317 }
318 }
319
320 void ciTypeStackSlotEntries::translate_type_data_from(const TypeStackSlotEntries* entries) {
321 for (int i = 0; i < number_of_entries(); i++) {
322 intptr_t k = entries->type(i);
323 Klass* klass = (Klass*)klass_part(k);
324 if (klass != nullptr && !klass->is_loader_alive()) {
325 // With concurrent class unloading, the MDO could have stale metadata; override it
326 TypeStackSlotEntries::set_type(i, TypeStackSlotEntries::with_status((Klass*)nullptr, k));
327 } else {
328 TypeStackSlotEntries::set_type(i, translate_klass(k));
329 }
330 }
331 }
332
333 void ciReturnTypeEntry::translate_type_data_from(const ReturnTypeEntry* ret) {
334 intptr_t k = ret->type();
335 Klass* klass = (Klass*)klass_part(k);
336 if (klass != nullptr && !klass->is_loader_alive()) {
337 // With concurrent class unloading, the MDO could have stale metadata; override it
338 set_type(ReturnTypeEntry::with_status((Klass*)nullptr, k));
339 } else {
340 set_type(translate_klass(k));
341 }
342 }
343
344 void ciSpeculativeTrapData::translate_from(const ProfileData* data) {
345 Method* m = data->as_SpeculativeTrapData()->method();
346 ciMethod* ci_m = CURRENT_ENV->get_method(m);
347 set_method(ci_m);
348 }
349
350 // Get the data at an arbitrary (sort of) data index.
351 ciProfileData* ciMethodData::data_at(int data_index) {
352 if (out_of_bounds(data_index)) {
353 return nullptr;
354 }
355 DataLayout* data_layout = data_layout_at(data_index);
356 return data_from(data_layout);
|
51 _saw_free_extra_data(false),
52 // Initialize the escape information (to "don't know.");
53 _eflags(0), _arg_local(0), _arg_stack(0), _arg_returned(0),
54 _invocation_counter(0),
55 _orig() {}
56
57 // Check for entries that reference an unloaded method
58 class PrepareExtraDataClosure : public CleanExtraDataClosure {
59 MethodData* _mdo;
60 SafepointStateTracker _safepoint_tracker;
61 GrowableArray<Method*> _uncached_methods;
62
63 public:
64 PrepareExtraDataClosure(MethodData* mdo)
65 : _mdo(mdo),
66 _safepoint_tracker(SafepointSynchronize::safepoint_state_tracker()),
67 _uncached_methods()
68 { }
69
70 bool is_live(Method* m) {
71 Klass* holder = m->method_holder();
72 if (holder == nullptr || // premain: not yet loaded
73 holder->class_loader_data() == nullptr ||
74 !holder->is_loader_alive() ||
75 (holder->is_instance_klass() && !InstanceKlass::cast(holder)->is_loaded())) {
76 return false;
77 }
78 if (CURRENT_ENV->cached_metadata(m) == nullptr) {
79 // Uncached entries need to be pre-populated.
80 _uncached_methods.append(m);
81 }
82 return true;
83 }
84
85 bool has_safepointed() {
86 return _safepoint_tracker.safepoint_state_changed();
87 }
88
89 bool finish() {
90 if (_uncached_methods.length() == 0) {
91 // Preparation finished iff all Methods* were already cached.
92 return true;
93 }
94 // We are currently holding the extra_data_lock and ensuring
95 // no safepoint breaks the lock.
290 _invocation_counter = 1;
291 }
292
293 _state = mdo->is_mature() ? mature_state : immature_state;
294 _eflags = mdo->eflags();
295 _arg_local = mdo->arg_local();
296 _arg_stack = mdo->arg_stack();
297 _arg_returned = mdo->arg_returned();
298 if (ReplayCompiles) {
299 ciReplay::initialize(this);
300 if (is_empty()) {
301 return false;
302 }
303 }
304 return true;
305 }
306
307 void ciReceiverTypeData::translate_receiver_data_from(const ProfileData* data) {
308 for (uint row = 0; row < row_limit(); row++) {
309 Klass* k = data->as_ReceiverTypeData()->receiver(row);
310 if (k != nullptr && k->class_loader_data() != nullptr &&
311 (!k->is_instance_klass() || InstanceKlass::cast(k)->is_loaded())) {
312 if (k->is_loader_alive()) {
313 ciKlass* klass = CURRENT_ENV->get_klass(k);
314 set_receiver(row, klass);
315 } else {
316 // With concurrent class unloading, the MDO could have stale metadata; override it
317 clear_row(row);
318 }
319 } else {
320 set_receiver(row, nullptr);
321 }
322 }
323 }
324
325 void ciTypeStackSlotEntries::translate_type_data_from(const TypeStackSlotEntries* entries) {
326 for (int i = 0; i < number_of_entries(); i++) {
327 intptr_t k = entries->type(i);
328 Klass* klass = (Klass*)klass_part(k);
329 if (klass != nullptr &&
330 ((klass->is_instance_klass() && !InstanceKlass::cast(klass)->is_loaded()) ||
331 (klass->class_loader_data() == nullptr || !klass->is_loader_alive()))) {
332 // With concurrent class unloading, the MDO could have stale metadata; override it
333 TypeStackSlotEntries::set_type(i, TypeStackSlotEntries::with_status((Klass*)nullptr, k));
334 } else {
335 TypeStackSlotEntries::set_type(i, translate_klass(k));
336 }
337 }
338 }
339
340 void ciReturnTypeEntry::translate_type_data_from(const ReturnTypeEntry* ret) {
341 intptr_t k = ret->type();
342 Klass* klass = (Klass*)klass_part(k);
343 if (klass != nullptr &&
344 ((klass->is_instance_klass() && !InstanceKlass::cast(klass)->is_loaded()) ||
345 (klass->class_loader_data() == nullptr || !klass->is_loader_alive()))) {
346 // With concurrent class unloading, the MDO could have stale metadata; override it
347 set_type(ReturnTypeEntry::with_status((Klass*)nullptr, k));
348 } else {
349 set_type(translate_klass(k));
350 }
351 }
352
353 void ciSpeculativeTrapData::translate_from(const ProfileData* data) {
354 Method* m = data->as_SpeculativeTrapData()->method();
355 ciMethod* ci_m = CURRENT_ENV->get_method(m);
356 set_method(ci_m);
357 }
358
359 // Get the data at an arbitrary (sort of) data index.
360 ciProfileData* ciMethodData::data_at(int data_index) {
361 if (out_of_bounds(data_index)) {
362 return nullptr;
363 }
364 DataLayout* data_layout = data_layout_at(data_index);
365 return data_from(data_layout);
|