jdk-sandbox: comparison hotspot/src/share/vm/c1/c1

equal deleted inserted replaced

-:3be8cae67887
+:fd885d66cb86
 }
 }
 // frequently used constants
-ConstantOopWriteValue LinearScan::_oop_null_scope_value = ConstantOopWriteValue(NULL);
+// Allocate them with new so they are never destroyed (otherwise, a
-ConstantIntValue      LinearScan::_int_m1_scope_value = ConstantIntValue(-1);
+// forced exit could destroy these objects while they are still in
-ConstantIntValue      LinearScan::_int_0_scope_value =  ConstantIntValue(0);
+// use).
-ConstantIntValue      LinearScan::_int_1_scope_value =  ConstantIntValue(1);
+ConstantOopWriteValue* LinearScan::_oop_null_scope_value = new (ResourceObj::C_HEAP) ConstantOopWriteValue(NULL);
-ConstantIntValue      LinearScan::_int_2_scope_value =  ConstantIntValue(2);
+ConstantIntValue*      LinearScan::_int_m1_scope_value = new (ResourceObj::C_HEAP) ConstantIntValue(-1);
-LocationValue         _illegal_value = LocationValue(Location());
+ConstantIntValue*      LinearScan::_int_0_scope_value =  new (ResourceObj::C_HEAP) ConstantIntValue(0);
+ConstantIntValue*      LinearScan::_int_1_scope_value =  new (ResourceObj::C_HEAP) ConstantIntValue(1);
+ConstantIntValue*      LinearScan::_int_2_scope_value =  new (ResourceObj::C_HEAP) ConstantIntValue(2);
+LocationValue*         _illegal_value = new (ResourceObj::C_HEAP) LocationValue(Location());
 void LinearScan::init_compute_debug_info() {
 // cache for frequently used scope values
 // (cpu registers and stack slots)
 _scope_value_cache = ScopeValueArray((LinearScan::nof_cpu_regs + frame_map()->argcount() + max_spills()) * 2, NULL);
 BasicType t = c->type();
 switch (t) {
 case T_OBJECT: {
 jobject value = c->as_jobject();
 if (value == NULL) {
-scope_values->append(&_oop_null_scope_value);
+scope_values->append(_oop_null_scope_value);
 } else {
 scope_values->append(new ConstantOopWriteValue(c->as_jobject()));
 }
 return 1;
 }
 case T_INT: // fall through
 case T_FLOAT: {
 int value = c->as_jint_bits();
 switch (value) {
-case -1: scope_values->append(&_int_m1_scope_value); break;
+case -1: scope_values->append(_int_m1_scope_value); break;
-case 0:  scope_values->append(&_int_0_scope_value); break;
+case 0:  scope_values->append(_int_0_scope_value); break;
-case 1:  scope_values->append(&_int_1_scope_value); break;
+case 1:  scope_values->append(_int_1_scope_value); break;
-case 2:  scope_values->append(&_int_2_scope_value); break;
+case 2:  scope_values->append(_int_2_scope_value); break;
 default: scope_values->append(new ConstantIntValue(c->as_jint_bits())); break;
 }
 return 1;
 }
 case T_LONG: // fall through
 case T_DOUBLE: {
 #ifdef _LP64
-scope_values->append(&_int_0_scope_value);
+scope_values->append(_int_0_scope_value);
 scope_values->append(new ConstantLongValue(c->as_jlong_bits()));
 #else
 if (hi_word_offset_in_bytes > lo_word_offset_in_bytes) {
 scope_values->append(new ConstantIntValue(c->as_jint_hi_bits()));
 scope_values->append(new ConstantIntValue(c->as_jint_lo_bits()));
 if (!frame_map()->locations_for_slot(opr->double_stack_ix(), loc_type, &loc1, NULL)) {
 bailout("too large frame");
 }
 // Does this reverse on x86 vs. sparc?
 first =  new LocationValue(loc1);
-second = &_int_0_scope_value;
+second = _int_0_scope_value;
 #else
 Location loc1, loc2;
 if (!frame_map()->locations_for_slot(opr->double_stack_ix(), Location::normal, &loc1, &loc2)) {
 bailout("too large frame");
 }
 } else if (opr->is_double_cpu()) {
 #ifdef _LP64
 VMReg rname_first = opr->as_register_lo()->as_VMReg();
 first = new LocationValue(Location::new_reg_loc(Location::lng, rname_first));
-second = &_int_0_scope_value;
+second = _int_0_scope_value;
 #else
 VMReg rname_first = opr->as_register_lo()->as_VMReg();
 VMReg rname_second = opr->as_register_hi()->as_VMReg();
 if (hi_word_offset_in_bytes < lo_word_offset_in_bytes) {
 } else if (opr->is_double_xmm()) {
 assert(opr->fpu_regnrLo() == opr->fpu_regnrHi(), "assumed in calculation");
 VMReg rname_first  = opr->as_xmm_double_reg()->as_VMReg();
 #  ifdef _LP64
 first = new LocationValue(Location::new_reg_loc(Location::dbl, rname_first));
-second = &_int_0_scope_value;
+second = _int_0_scope_value;
 #  else
 first = new LocationValue(Location::new_reg_loc(Location::normal, rname_first));
 // %%% This is probably a waste but we'll keep things as they were for now
 if (true) {
 VMReg rname_second = rname_first->next();
 VMReg rname_first = frame_map()->fpu_regname(opr->fpu_regnrHi());
 #endif
 #ifdef _LP64
 first = new LocationValue(Location::new_reg_loc(Location::dbl, rname_first));
-second = &_int_0_scope_value;
+second = _int_0_scope_value;
 #else
 first = new LocationValue(Location::new_reg_loc(Location::normal, rname_first));
 // %%% This is probably a waste but we'll keep things as they were for now
 if (true) {
 VMReg rname_second = rname_first->next();
 return append_scope_value_for_constant(opr, scope_values);
 }
 } else {
 // append a dummy value because real value not needed
-scope_values->append(&_illegal_value);
+scope_values->append(_illegal_value);
 return 1;
 }
 }
 } else if (cur_scope->method()->max_locals() > 0) {
 assert(cur_state->kind() == ValueStack::EmptyExceptionState, "should be");
 nof_locals = cur_scope->method()->max_locals();
 locals = new GrowableArray<ScopeValue*>(nof_locals);
 for(int i = 0; i < nof_locals; i++) {
-locals->append(&_illegal_value);
+locals->append(_illegal_value);
 }
 }
 // describe expression stack
 int nof_stack = cur_state->stack_size();

changeset 11792	fd885d66cb86
parent 10732	6a893b38ee30
child 11964	96fb8c3562f7