graal-jvmci-8: src/share/vm/opto/library

comparison src/share/vm/opto/library_call.cpp @ 900:9987d9d5eb0e

6833129: specjvm98 fails with NullPointerException in the compiler with -XX:DeoptimizeALot Summary: developed a reexecute logic for the interpreter to reexecute the bytecode when deopt happens Reviewed-by: kvn, never, jrose, twisti

author	cfang
date	Fri, 31 Jul 2009 17:12:33 -0700
parents	1cef5ec3ca56
children	fc2281ddce3c

comparison

equal deleted inserted replaced

-:55cb84cd1247
+:9987d9d5eb0e
 uncommon_trap(Deoptimization::Reason_intrinsic,
 Deoptimization::Action_maybe_recompile);
 }
 if (!stopped()) {
-// How many elements will we copy from the original?
+Node *newcopy;
-// The answer is MinI(orig_length - start, length).
+//set the original stack and the reexecute bit for the interpreter to reexecute
-Node* orig_tail = _gvn.transform( new(C, 3) SubINode(orig_length, start) );
+//the bytecode that invokes Arrays.copyOf if deoptimization happens
-Node* moved = generate_min_max(vmIntrinsics::_min, orig_tail, length);
+{ PreserveReexecuteState preexecs(this);
+_sp += nargs;
-const bool raw_mem_only = true;
+jvms()->set_should_reexecute(true);
-Node* newcopy = new_array(klass_node, length, nargs, raw_mem_only);
+// How many elements will we copy from the original?
-// Generate a direct call to the right arraycopy function(s).
+// The answer is MinI(orig_length - start, length).
-// We know the copy is disjoint but we might not know if the
+Node* orig_tail = _gvn.transform( new(C, 3) SubINode(orig_length, start) );
-// oop stores need checking.
+Node* moved = generate_min_max(vmIntrinsics::_min, orig_tail, length);
-// Extreme case:  Arrays.copyOf((Integer[])x, 10, String[].class).
-// This will fail a store-check if x contains any non-nulls.
+const bool raw_mem_only = true;
-bool disjoint_bases = true;
+newcopy = new_array(klass_node, length, 0, raw_mem_only);
-bool length_never_negative = true;
-generate_arraycopy(TypeAryPtr::OOPS, T_OBJECT,
+// Generate a direct call to the right arraycopy function(s).
-original, start, newcopy, intcon(0), moved,
+// We know the copy is disjoint but we might not know if the
-disjoint_bases, length_never_negative);
+// oop stores need checking.
+// Extreme case:  Arrays.copyOf((Integer[])x, 10, String[].class).
+// This will fail a store-check if x contains any non-nulls.
+bool disjoint_bases = true;
+bool length_never_negative = true;
+generate_arraycopy(TypeAryPtr::OOPS, T_OBJECT,
+original, start, newcopy, intcon(0), moved,
+disjoint_bases, length_never_negative);
+} //original reexecute and sp are set back here
 push(newcopy);
 }
 C->set_has_split_ifs(true); // Has chance for split-if optimization
 const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
 int raw_adr_idx = Compile::AliasIdxRaw;
 const bool raw_mem_only = true;
-Node* array_ctl = generate_array_guard(obj_klass, (RegionNode*)NULL);
+//set the original stack and the reexecute bit for the interpreter to reexecute
-if (array_ctl != NULL) {
+//the bytecode that invokes Object.clone if deoptimization happens
-// It's an array.
+{ PreserveReexecuteState preexecs(this);
-PreserveJVMState pjvms(this);
+_sp += nargs;
-set_control(array_ctl);
+jvms()->set_should_reexecute(true);
-Node* obj_length = load_array_length(obj);
-Node* obj_size = NULL;
+Node* array_ctl = generate_array_guard(obj_klass, (RegionNode*)NULL);
-Node* alloc_obj = new_array(obj_klass, obj_length, nargs,
+if (array_ctl != NULL) {
-raw_mem_only, &obj_size);
+// It's an array.
+PreserveJVMState pjvms(this);
-if (!use_ReduceInitialCardMarks()) {
+set_control(array_ctl);
-// If it is an oop array, it requires very special treatment,
+Node* obj_length = load_array_length(obj);
-// because card marking is required on each card of the array.
+Node* obj_size  = NULL;
-Node* is_obja = generate_objArray_guard(obj_klass, (RegionNode*)NULL);
+Node* alloc_obj = new_array(obj_klass, obj_length, 0,
-if (is_obja != NULL) {
+raw_mem_only, &obj_size);
-PreserveJVMState pjvms2(this);
-set_control(is_obja);
+if (!use_ReduceInitialCardMarks()) {
-// Generate a direct call to the right arraycopy function(s).
+// If it is an oop array, it requires very special treatment,
-bool disjoint_bases = true;
+// because card marking is required on each card of the array.
-bool length_never_negative = true;
+Node* is_obja = generate_objArray_guard(obj_klass, (RegionNode*)NULL);
-generate_arraycopy(TypeAryPtr::OOPS, T_OBJECT,
+if (is_obja != NULL) {
-obj, intcon(0), alloc_obj, intcon(0),
+PreserveJVMState pjvms2(this);
-obj_length,
+set_control(is_obja);
-disjoint_bases, length_never_negative);
+// Generate a direct call to the right arraycopy function(s).
-result_reg->init_req(_objArray_path, control());
+bool disjoint_bases = true;
-result_val->init_req(_objArray_path, alloc_obj);
+bool length_never_negative = true;
-result_i_o ->set_req(_objArray_path, i_o());
+generate_arraycopy(TypeAryPtr::OOPS, T_OBJECT,
-result_mem ->set_req(_objArray_path, reset_memory());
+obj, intcon(0), alloc_obj, intcon(0),
+obj_length,
+disjoint_bases, length_never_negative);
+result_reg->init_req(_objArray_path, control());
+result_val->init_req(_objArray_path, alloc_obj);
+result_i_o ->set_req(_objArray_path, i_o());
+result_mem ->set_req(_objArray_path, reset_memory());
+}
 }
-}
+// We can dispense with card marks if we know the allocation
-// We can dispense with card marks if we know the allocation
+// comes out of eden (TLAB)...  In fact, ReduceInitialCardMarks
-// comes out of eden (TLAB)...  In fact, ReduceInitialCardMarks
+// causes the non-eden paths to simulate a fresh allocation,
-// causes the non-eden paths to simulate a fresh allocation,
+// insofar that no further card marks are required to initialize
-// insofar that no further card marks are required to initialize
+// the object.
-// the object.
+// Otherwise, there are no card marks to worry about.
-// Otherwise, there are no card marks to worry about.
+if (!stopped()) {
+copy_to_clone(obj, alloc_obj, obj_size, true, false);
+// Present the results of the copy.
+result_reg->init_req(_array_path, control());
+result_val->init_req(_array_path, alloc_obj);
+result_i_o ->set_req(_array_path, i_o());
+result_mem ->set_req(_array_path, reset_memory());
+}
+}
+// We only go to the instance fast case code if we pass a number of guards.
+// The paths which do not pass are accumulated in the slow_region.
+RegionNode* slow_region = new (C, 1) RegionNode(1);
+record_for_igvn(slow_region);
 if (!stopped()) {
-copy_to_clone(obj, alloc_obj, obj_size, true, false);
+// It's an instance (we did array above).  Make the slow-path tests.
+// If this is a virtual call, we generate a funny guard.  We grab
-// Present the results of the copy.
+// the vtable entry corresponding to clone() from the target object.
-result_reg->init_req(_array_path, control());
+// If the target method which we are calling happens to be the
-result_val->init_req(_array_path, alloc_obj);
+// Object clone() method, we pass the guard.  We do not need this
-result_i_o ->set_req(_array_path, i_o());
+// guard for non-virtual calls; the caller is known to be the native
-result_mem ->set_req(_array_path, reset_memory());
+// Object clone().
-}
+if (is_virtual) {
-}
+generate_virtual_guard(obj_klass, slow_region);
+}
-// We only go to the instance fast case code if we pass a number of guards.
-// The paths which do not pass are accumulated in the slow_region.
+// The object must be cloneable and must not have a finalizer.
-RegionNode* slow_region = new (C, 1) RegionNode(1);
+// Both of these conditions may be checked in a single test.
-record_for_igvn(slow_region);
+// We could optimize the cloneable test further, but we don't care.
-if (!stopped()) {
+generate_access_flags_guard(obj_klass,
-// It's an instance (we did array above).  Make the slow-path tests.
+// Test both conditions:
-// If this is a virtual call, we generate a funny guard.  We grab
+JVM_ACC_IS_CLONEABLE | JVM_ACC_HAS_FINALIZER,
-// the vtable entry corresponding to clone() from the target object.
+// Must be cloneable but not finalizer:
-// If the target method which we are calling happens to be the
+JVM_ACC_IS_CLONEABLE,
-// Object clone() method, we pass the guard.  We do not need this
+slow_region);
-// guard for non-virtual calls; the caller is known to be the native
+}
-// Object clone().
-if (is_virtual) {
+if (!stopped()) {
-generate_virtual_guard(obj_klass, slow_region);
+// It's an instance, and it passed the slow-path tests.
-}
+PreserveJVMState pjvms(this);
+Node* obj_size  = NULL;
-// The object must be cloneable and must not have a finalizer.
+Node* alloc_obj = new_instance(obj_klass, NULL, raw_mem_only, &obj_size);
-// Both of these conditions may be checked in a single test.
-// We could optimize the cloneable test further, but we don't care.
+copy_to_clone(obj, alloc_obj, obj_size, false, !use_ReduceInitialCardMarks());
-generate_access_flags_guard(obj_klass,
-// Test both conditions:
+// Present the results of the slow call.
-JVM_ACC_IS_CLONEABLE | JVM_ACC_HAS_FINALIZER,
+result_reg->init_req(_instance_path, control());
-// Must be cloneable but not finalizer:
+result_val->init_req(_instance_path, alloc_obj);
-JVM_ACC_IS_CLONEABLE,
+result_i_o ->set_req(_instance_path, i_o());
-slow_region);
+result_mem ->set_req(_instance_path, reset_memory());
 }
-if (!stopped()) {
+// Generate code for the slow case.  We make a call to clone().
-// It's an instance, and it passed the slow-path tests.
+set_control(_gvn.transform(slow_region));
-PreserveJVMState pjvms(this);
+if (!stopped()) {
-Node* obj_size = NULL;
+PreserveJVMState pjvms(this);
-Node* alloc_obj = new_instance(obj_klass, NULL, raw_mem_only, &obj_size);
+CallJavaNode* slow_call = generate_method_call(vmIntrinsics::_clone, is_virtual);
+Node* slow_result = set_results_for_java_call(slow_call);
-copy_to_clone(obj, alloc_obj, obj_size, false, !use_ReduceInitialCardMarks());
+// this->control() comes from set_results_for_java_call
+result_reg->init_req(_slow_path, control());
-// Present the results of the slow call.
+result_val->init_req(_slow_path, slow_result);
-result_reg->init_req(_instance_path, control());
+result_i_o ->set_req(_slow_path, i_o());
-result_val->init_req(_instance_path, alloc_obj);
+result_mem ->set_req(_slow_path, reset_memory());
-result_i_o ->set_req(_instance_path, i_o());
+}
-result_mem ->set_req(_instance_path, reset_memory());
+} //original reexecute and sp are set back here
-}
-// Generate code for the slow case.  We make a call to clone().
-set_control(_gvn.transform(slow_region));
-if (!stopped()) {
-PreserveJVMState pjvms(this);
-CallJavaNode* slow_call = generate_method_call(vmIntrinsics::_clone, is_virtual);
-Node* slow_result = set_results_for_java_call(slow_call);
-// this->control() comes from set_results_for_java_call
-result_reg->init_req(_slow_path, control());
-result_val->init_req(_slow_path, slow_result);
-result_i_o ->set_req(_slow_path, i_o());
-result_mem ->set_req(_slow_path, reset_memory());
-}
 // Return the combined state.
 set_control(    _gvn.transform(result_reg) );
 set_i_o(        _gvn.transform(result_i_o) );
 set_all_memory( _gvn.transform(result_mem) );

Mercurial > hg > graal-jvmci-8

comparison src/share/vm/opto/library_call.cpp @ 900:9987d9d5eb0e