492 // take the uncommon_trap in the BuildCutout below. |
492 // take the uncommon_trap in the BuildCutout below. |
493 |
493 |
494 // first must access the should_post_on_exceptions_flag in this thread's JavaThread |
494 // first must access the should_post_on_exceptions_flag in this thread's JavaThread |
495 Node* jthread = _gvn.transform(new (C) ThreadLocalNode()); |
495 Node* jthread = _gvn.transform(new (C) ThreadLocalNode()); |
496 Node* adr = basic_plus_adr(top(), jthread, in_bytes(JavaThread::should_post_on_exceptions_flag_offset())); |
496 Node* adr = basic_plus_adr(top(), jthread, in_bytes(JavaThread::should_post_on_exceptions_flag_offset())); |
497 Node* should_post_flag = make_load(control(), adr, TypeInt::INT, T_INT, Compile::AliasIdxRaw, false); |
497 Node* should_post_flag = make_load(control(), adr, TypeInt::INT, T_INT, Compile::AliasIdxRaw, MemNode::unordered); |
498 |
498 |
499 // Test the should_post_on_exceptions_flag vs. 0 |
499 // Test the should_post_on_exceptions_flag vs. 0 |
500 Node* chk = _gvn.transform( new (C) CmpINode(should_post_flag, intcon(0)) ); |
500 Node* chk = _gvn.transform( new (C) CmpINode(should_post_flag, intcon(0)) ); |
501 Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) ); |
501 Node* tst = _gvn.transform( new (C) BoolNode(chk, BoolTest::eq) ); |
502 |
502 |
594 int offset = java_lang_Throwable::get_detailMessage_offset(); |
594 int offset = java_lang_Throwable::get_detailMessage_offset(); |
595 const TypePtr* adr_typ = ex_con->add_offset(offset); |
595 const TypePtr* adr_typ = ex_con->add_offset(offset); |
596 |
596 |
597 Node *adr = basic_plus_adr(ex_node, ex_node, offset); |
597 Node *adr = basic_plus_adr(ex_node, ex_node, offset); |
598 const TypeOopPtr* val_type = TypeOopPtr::make_from_klass(env()->String_klass()); |
598 const TypeOopPtr* val_type = TypeOopPtr::make_from_klass(env()->String_klass()); |
599 Node *store = store_oop_to_object(control(), ex_node, adr, adr_typ, null(), val_type, T_OBJECT); |
599 // Conservatively release stores of object references. |
|
600 Node *store = store_oop_to_object(control(), ex_node, adr, adr_typ, null(), val_type, T_OBJECT, MemNode::release); |
600 |
601 |
601 add_exception_state(make_exception_state(ex_node)); |
602 add_exception_state(make_exception_state(ex_node)); |
602 return; |
603 return; |
603 } |
604 } |
604 } |
605 } |
1481 // |
1482 // |
1482 |
1483 |
1483 // factory methods in "int adr_idx" |
1484 // factory methods in "int adr_idx" |
1484 Node* GraphKit::make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, |
1485 Node* GraphKit::make_load(Node* ctl, Node* adr, const Type* t, BasicType bt, |
1485 int adr_idx, |
1486 int adr_idx, |
1486 bool require_atomic_access) { |
1487 MemNode::MemOrd mo, bool require_atomic_access) { |
1487 assert(adr_idx != Compile::AliasIdxTop, "use other make_load factory" ); |
1488 assert(adr_idx != Compile::AliasIdxTop, "use other make_load factory" ); |
1488 const TypePtr* adr_type = NULL; // debug-mode-only argument |
1489 const TypePtr* adr_type = NULL; // debug-mode-only argument |
1489 debug_only(adr_type = C->get_adr_type(adr_idx)); |
1490 debug_only(adr_type = C->get_adr_type(adr_idx)); |
1490 Node* mem = memory(adr_idx); |
1491 Node* mem = memory(adr_idx); |
1491 Node* ld; |
1492 Node* ld; |
1492 if (require_atomic_access && bt == T_LONG) { |
1493 if (require_atomic_access && bt == T_LONG) { |
1493 ld = LoadLNode::make_atomic(C, ctl, mem, adr, adr_type, t); |
1494 ld = LoadLNode::make_atomic(C, ctl, mem, adr, adr_type, t, mo); |
1494 } else { |
1495 } else { |
1495 ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt); |
1496 ld = LoadNode::make(_gvn, ctl, mem, adr, adr_type, t, bt, mo); |
1496 } |
1497 } |
1497 ld = _gvn.transform(ld); |
1498 ld = _gvn.transform(ld); |
1498 if ((bt == T_OBJECT) && C->do_escape_analysis() || C->eliminate_boxing()) { |
1499 if ((bt == T_OBJECT) && C->do_escape_analysis() || C->eliminate_boxing()) { |
1499 // Improve graph before escape analysis and boxing elimination. |
1500 // Improve graph before escape analysis and boxing elimination. |
1500 record_for_igvn(ld); |
1501 record_for_igvn(ld); |
1502 return ld; |
1503 return ld; |
1503 } |
1504 } |
1504 |
1505 |
1505 Node* GraphKit::store_to_memory(Node* ctl, Node* adr, Node *val, BasicType bt, |
1506 Node* GraphKit::store_to_memory(Node* ctl, Node* adr, Node *val, BasicType bt, |
1506 int adr_idx, |
1507 int adr_idx, |
|
1508 MemNode::MemOrd mo, |
1507 bool require_atomic_access) { |
1509 bool require_atomic_access) { |
1508 assert(adr_idx != Compile::AliasIdxTop, "use other store_to_memory factory" ); |
1510 assert(adr_idx != Compile::AliasIdxTop, "use other store_to_memory factory" ); |
1509 const TypePtr* adr_type = NULL; |
1511 const TypePtr* adr_type = NULL; |
1510 debug_only(adr_type = C->get_adr_type(adr_idx)); |
1512 debug_only(adr_type = C->get_adr_type(adr_idx)); |
1511 Node *mem = memory(adr_idx); |
1513 Node *mem = memory(adr_idx); |
1512 Node* st; |
1514 Node* st; |
1513 if (require_atomic_access && bt == T_LONG) { |
1515 if (require_atomic_access && bt == T_LONG) { |
1514 st = StoreLNode::make_atomic(C, ctl, mem, adr, adr_type, val); |
1516 st = StoreLNode::make_atomic(C, ctl, mem, adr, adr_type, val, mo); |
1515 } else { |
1517 } else { |
1516 st = StoreNode::make(_gvn, ctl, mem, adr, adr_type, val, bt); |
1518 st = StoreNode::make(_gvn, ctl, mem, adr, adr_type, val, bt, mo); |
1517 } |
1519 } |
1518 st = _gvn.transform(st); |
1520 st = _gvn.transform(st); |
1519 set_memory(st, adr_idx); |
1521 set_memory(st, adr_idx); |
1520 // Back-to-back stores can only remove intermediate store with DU info |
1522 // Back-to-back stores can only remove intermediate store with DU info |
1521 // so push on worklist for optimizer. |
1523 // so push on worklist for optimizer. |
1611 Node* adr, |
1613 Node* adr, |
1612 const TypePtr* adr_type, |
1614 const TypePtr* adr_type, |
1613 Node* val, |
1615 Node* val, |
1614 const TypeOopPtr* val_type, |
1616 const TypeOopPtr* val_type, |
1615 BasicType bt, |
1617 BasicType bt, |
1616 bool use_precise) { |
1618 bool use_precise, |
|
1619 MemNode::MemOrd mo) { |
1617 // Transformation of a value which could be NULL pointer (CastPP #NULL) |
1620 // Transformation of a value which could be NULL pointer (CastPP #NULL) |
1618 // could be delayed during Parse (for example, in adjust_map_after_if()). |
1621 // could be delayed during Parse (for example, in adjust_map_after_if()). |
1619 // Execute transformation here to avoid barrier generation in such case. |
1622 // Execute transformation here to avoid barrier generation in such case. |
1620 if (_gvn.type(val) == TypePtr::NULL_PTR) |
1623 if (_gvn.type(val) == TypePtr::NULL_PTR) |
1621 val = _gvn.makecon(TypePtr::NULL_PTR); |
1624 val = _gvn.makecon(TypePtr::NULL_PTR); |
1631 pre_barrier(true /* do_load */, |
1634 pre_barrier(true /* do_load */, |
1632 control(), obj, adr, adr_idx, val, val_type, |
1635 control(), obj, adr, adr_idx, val, val_type, |
1633 NULL /* pre_val */, |
1636 NULL /* pre_val */, |
1634 bt); |
1637 bt); |
1635 |
1638 |
1636 Node* store = store_to_memory(control(), adr, val, bt, adr_idx); |
1639 Node* store = store_to_memory(control(), adr, val, bt, adr_idx, mo); |
1637 post_barrier(control(), store, obj, adr, adr_idx, val, bt, use_precise); |
1640 post_barrier(control(), store, obj, adr, adr_idx, val, bt, use_precise); |
1638 return store; |
1641 return store; |
1639 } |
1642 } |
1640 |
1643 |
1641 // Could be an array or object we don't know at compile time (unsafe ref.) |
1644 // Could be an array or object we don't know at compile time (unsafe ref.) |
1642 Node* GraphKit::store_oop_to_unknown(Node* ctl, |
1645 Node* GraphKit::store_oop_to_unknown(Node* ctl, |
1643 Node* obj, // containing obj |
1646 Node* obj, // containing obj |
1644 Node* adr, // actual adress to store val at |
1647 Node* adr, // actual adress to store val at |
1645 const TypePtr* adr_type, |
1648 const TypePtr* adr_type, |
1646 Node* val, |
1649 Node* val, |
1647 BasicType bt) { |
1650 BasicType bt, |
|
1651 MemNode::MemOrd mo) { |
1648 Compile::AliasType* at = C->alias_type(adr_type); |
1652 Compile::AliasType* at = C->alias_type(adr_type); |
1649 const TypeOopPtr* val_type = NULL; |
1653 const TypeOopPtr* val_type = NULL; |
1650 if (adr_type->isa_instptr()) { |
1654 if (adr_type->isa_instptr()) { |
1651 if (at->field() != NULL) { |
1655 if (at->field() != NULL) { |
1652 // known field. This code is a copy of the do_put_xxx logic. |
1656 // known field. This code is a copy of the do_put_xxx logic. |
1661 val_type = adr_type->is_aryptr()->elem()->make_oopptr(); |
1665 val_type = adr_type->is_aryptr()->elem()->make_oopptr(); |
1662 } |
1666 } |
1663 if (val_type == NULL) { |
1667 if (val_type == NULL) { |
1664 val_type = TypeInstPtr::BOTTOM; |
1668 val_type = TypeInstPtr::BOTTOM; |
1665 } |
1669 } |
1666 return store_oop(ctl, obj, adr, adr_type, val, val_type, bt, true); |
1670 return store_oop(ctl, obj, adr, adr_type, val, val_type, bt, true, mo); |
1667 } |
1671 } |
1668 |
1672 |
1669 |
1673 |
1670 //-------------------------array_element_address------------------------- |
1674 //-------------------------array_element_address------------------------- |
1671 Node* GraphKit::array_element_address(Node* ary, Node* idx, BasicType elembt, |
1675 Node* GraphKit::array_element_address(Node* ary, Node* idx, BasicType elembt, |
1705 //-------------------------load_array_element------------------------- |
1709 //-------------------------load_array_element------------------------- |
1706 Node* GraphKit::load_array_element(Node* ctl, Node* ary, Node* idx, const TypeAryPtr* arytype) { |
1710 Node* GraphKit::load_array_element(Node* ctl, Node* ary, Node* idx, const TypeAryPtr* arytype) { |
1707 const Type* elemtype = arytype->elem(); |
1711 const Type* elemtype = arytype->elem(); |
1708 BasicType elembt = elemtype->array_element_basic_type(); |
1712 BasicType elembt = elemtype->array_element_basic_type(); |
1709 Node* adr = array_element_address(ary, idx, elembt, arytype->size()); |
1713 Node* adr = array_element_address(ary, idx, elembt, arytype->size()); |
1710 Node* ld = make_load(ctl, adr, elemtype, elembt, arytype); |
1714 Node* ld = make_load(ctl, adr, elemtype, elembt, arytype, MemNode::unordered); |
1711 return ld; |
1715 return ld; |
1712 } |
1716 } |
1713 |
1717 |
1714 //-------------------------set_arguments_for_java_call------------------------- |
1718 //-------------------------set_arguments_for_java_call------------------------- |
1715 // Arguments (pre-popped from the stack) are taken from the JVMS. |
1719 // Arguments (pre-popped from the stack) are taken from the JVMS. |
1940 } |
1944 } |
1941 |
1945 |
1942 void GraphKit::increment_counter(Node* counter_addr) { |
1946 void GraphKit::increment_counter(Node* counter_addr) { |
1943 int adr_type = Compile::AliasIdxRaw; |
1947 int adr_type = Compile::AliasIdxRaw; |
1944 Node* ctrl = control(); |
1948 Node* ctrl = control(); |
1945 Node* cnt = make_load(ctrl, counter_addr, TypeInt::INT, T_INT, adr_type); |
1949 Node* cnt = make_load(ctrl, counter_addr, TypeInt::INT, T_INT, adr_type, MemNode::unordered); |
1946 Node* incr = _gvn.transform(new (C) AddINode(cnt, _gvn.intcon(1))); |
1950 Node* incr = _gvn.transform(new (C) AddINode(cnt, _gvn.intcon(1))); |
1947 store_to_memory( ctrl, counter_addr, incr, T_INT, adr_type ); |
1951 store_to_memory(ctrl, counter_addr, incr, T_INT, adr_type, MemNode::unordered); |
1948 } |
1952 } |
1949 |
1953 |
1950 |
1954 |
1951 //------------------------------uncommon_trap---------------------------------- |
1955 //------------------------------uncommon_trap---------------------------------- |
1952 // Bail out to the interpreter in mid-method. Implemented by calling the |
1956 // Bail out to the interpreter in mid-method. Implemented by calling the |
2523 // if the subklass is the unique subtype of the superklass, the check |
2527 // if the subklass is the unique subtype of the superklass, the check |
2524 // will always succeed. We could leave a dependency behind to ensure this. |
2528 // will always succeed. We could leave a dependency behind to ensure this. |
2525 |
2529 |
2526 // First load the super-klass's check-offset |
2530 // First load the super-klass's check-offset |
2527 Node *p1 = basic_plus_adr( superklass, superklass, in_bytes(Klass::super_check_offset_offset()) ); |
2531 Node *p1 = basic_plus_adr( superklass, superklass, in_bytes(Klass::super_check_offset_offset()) ); |
2528 Node *chk_off = _gvn.transform( new (C) LoadINode( NULL, memory(p1), p1, _gvn.type(p1)->is_ptr() ) ); |
2532 Node *chk_off = _gvn.transform(new (C) LoadINode(NULL, memory(p1), p1, _gvn.type(p1)->is_ptr(), |
|
2533 TypeInt::INT, MemNode::unordered)); |
2529 int cacheoff_con = in_bytes(Klass::secondary_super_cache_offset()); |
2534 int cacheoff_con = in_bytes(Klass::secondary_super_cache_offset()); |
2530 bool might_be_cache = (find_int_con(chk_off, cacheoff_con) == cacheoff_con); |
2535 bool might_be_cache = (find_int_con(chk_off, cacheoff_con) == cacheoff_con); |
2531 |
2536 |
2532 // Load from the sub-klass's super-class display list, or a 1-word cache of |
2537 // Load from the sub-klass's super-class display list, or a 1-word cache of |
2533 // the secondary superclass list, or a failing value with a sentinel offset |
2538 // the secondary superclass list, or a failing value with a sentinel offset |
3236 } |
3241 } |
3237 } |
3242 } |
3238 } |
3243 } |
3239 constant_value = Klass::_lh_neutral_value; // put in a known value |
3244 constant_value = Klass::_lh_neutral_value; // put in a known value |
3240 Node* lhp = basic_plus_adr(klass_node, klass_node, in_bytes(Klass::layout_helper_offset())); |
3245 Node* lhp = basic_plus_adr(klass_node, klass_node, in_bytes(Klass::layout_helper_offset())); |
3241 return make_load(NULL, lhp, TypeInt::INT, T_INT); |
3246 return make_load(NULL, lhp, TypeInt::INT, T_INT, MemNode::unordered); |
3242 } |
3247 } |
3243 |
3248 |
3244 // We just put in an allocate/initialize with a big raw-memory effect. |
3249 // We just put in an allocate/initialize with a big raw-memory effect. |
3245 // Hook selected additional alias categories on the initialization. |
3250 // Hook selected additional alias categories on the initialization. |
3246 static void hook_memory_on_init(GraphKit& kit, int alias_idx, |
3251 static void hook_memory_on_init(GraphKit& kit, int alias_idx, |
3771 __ if_then(card_val, BoolTest::ne, zero); |
3776 __ if_then(card_val, BoolTest::ne, zero); |
3772 } |
3777 } |
3773 |
3778 |
3774 // Smash zero into card |
3779 // Smash zero into card |
3775 if( !UseConcMarkSweepGC ) { |
3780 if( !UseConcMarkSweepGC ) { |
3776 __ store(__ ctrl(), card_adr, zero, bt, adr_type); |
3781 __ store(__ ctrl(), card_adr, zero, bt, adr_type, MemNode::release); |
3777 } else { |
3782 } else { |
3778 // Specialized path for CM store barrier |
3783 // Specialized path for CM store barrier |
3779 __ storeCM(__ ctrl(), card_adr, zero, oop_store, adr_idx, bt, adr_type); |
3784 __ storeCM(__ ctrl(), card_adr, zero, oop_store, adr_idx, bt, adr_type); |
3780 } |
3785 } |
3781 |
3786 |
3868 // decrement the index |
3873 // decrement the index |
3869 Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t)))); |
3874 Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t)))); |
3870 |
3875 |
3871 // Now get the buffer location we will log the previous value into and store it |
3876 // Now get the buffer location we will log the previous value into and store it |
3872 Node *log_addr = __ AddP(no_base, buffer, next_index); |
3877 Node *log_addr = __ AddP(no_base, buffer, next_index); |
3873 __ store(__ ctrl(), log_addr, pre_val, T_OBJECT, Compile::AliasIdxRaw); |
3878 __ store(__ ctrl(), log_addr, pre_val, T_OBJECT, Compile::AliasIdxRaw, MemNode::unordered); |
3874 // update the index |
3879 // update the index |
3875 __ store(__ ctrl(), index_adr, next_index, index_bt, Compile::AliasIdxRaw); |
3880 __ store(__ ctrl(), index_adr, next_index, index_bt, Compile::AliasIdxRaw, MemNode::unordered); |
3876 |
3881 |
3877 } __ else_(); { |
3882 } __ else_(); { |
3878 |
3883 |
3879 // logging buffer is full, call the runtime |
3884 // logging buffer is full, call the runtime |
3880 const TypeFunc *tf = OptoRuntime::g1_wb_pre_Type(); |
3885 const TypeFunc *tf = OptoRuntime::g1_wb_pre_Type(); |
3910 __ if_then(index, BoolTest::ne, zeroX); { |
3915 __ if_then(index, BoolTest::ne, zeroX); { |
3911 |
3916 |
3912 Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t)))); |
3917 Node* next_index = _gvn.transform(new (C) SubXNode(index, __ ConX(sizeof(intptr_t)))); |
3913 Node* log_addr = __ AddP(no_base, buffer, next_index); |
3918 Node* log_addr = __ AddP(no_base, buffer, next_index); |
3914 |
3919 |
3915 __ store(__ ctrl(), log_addr, card_adr, T_ADDRESS, Compile::AliasIdxRaw); |
3920 // Order, see storeCM. |
3916 __ store(__ ctrl(), index_adr, next_index, TypeX_X->basic_type(), Compile::AliasIdxRaw); |
3921 __ store(__ ctrl(), log_addr, card_adr, T_ADDRESS, Compile::AliasIdxRaw, MemNode::unordered); |
|
3922 __ store(__ ctrl(), index_adr, next_index, TypeX_X->basic_type(), Compile::AliasIdxRaw, MemNode::unordered); |
3917 |
3923 |
3918 } __ else_(); { |
3924 } __ else_(); { |
3919 __ make_leaf_call(tf, CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_post), "g1_wb_post", card_adr, __ thread()); |
3925 __ make_leaf_call(tf, CAST_FROM_FN_PTR(address, SharedRuntime::g1_wb_post), "g1_wb_post", card_adr, __ thread()); |
3920 } __ end_if(); |
3926 } __ end_if(); |
3921 |
3927 |
4041 false, NULL, 0); |
4047 false, NULL, 0); |
4042 const TypePtr* offset_field_type = string_type->add_offset(offset_offset); |
4048 const TypePtr* offset_field_type = string_type->add_offset(offset_offset); |
4043 int offset_field_idx = C->get_alias_index(offset_field_type); |
4049 int offset_field_idx = C->get_alias_index(offset_field_type); |
4044 return make_load(ctrl, |
4050 return make_load(ctrl, |
4045 basic_plus_adr(str, str, offset_offset), |
4051 basic_plus_adr(str, str, offset_offset), |
4046 TypeInt::INT, T_INT, offset_field_idx); |
4052 TypeInt::INT, T_INT, offset_field_idx, MemNode::unordered); |
4047 } else { |
4053 } else { |
4048 return intcon(0); |
4054 return intcon(0); |
4049 } |
4055 } |
4050 } |
4056 } |
4051 |
4057 |
4056 false, NULL, 0); |
4062 false, NULL, 0); |
4057 const TypePtr* count_field_type = string_type->add_offset(count_offset); |
4063 const TypePtr* count_field_type = string_type->add_offset(count_offset); |
4058 int count_field_idx = C->get_alias_index(count_field_type); |
4064 int count_field_idx = C->get_alias_index(count_field_type); |
4059 return make_load(ctrl, |
4065 return make_load(ctrl, |
4060 basic_plus_adr(str, str, count_offset), |
4066 basic_plus_adr(str, str, count_offset), |
4061 TypeInt::INT, T_INT, count_field_idx); |
4067 TypeInt::INT, T_INT, count_field_idx, MemNode::unordered); |
4062 } else { |
4068 } else { |
4063 return load_array_length(load_String_value(ctrl, str)); |
4069 return load_array_length(load_String_value(ctrl, str)); |
4064 } |
4070 } |
4065 } |
4071 } |
4066 |
4072 |
4072 const TypeAryPtr* value_type = TypeAryPtr::make(TypePtr::NotNull, |
4078 const TypeAryPtr* value_type = TypeAryPtr::make(TypePtr::NotNull, |
4073 TypeAry::make(TypeInt::CHAR,TypeInt::POS), |
4079 TypeAry::make(TypeInt::CHAR,TypeInt::POS), |
4074 ciTypeArrayKlass::make(T_CHAR), true, 0); |
4080 ciTypeArrayKlass::make(T_CHAR), true, 0); |
4075 int value_field_idx = C->get_alias_index(value_field_type); |
4081 int value_field_idx = C->get_alias_index(value_field_type); |
4076 Node* load = make_load(ctrl, basic_plus_adr(str, str, value_offset), |
4082 Node* load = make_load(ctrl, basic_plus_adr(str, str, value_offset), |
4077 value_type, T_OBJECT, value_field_idx); |
4083 value_type, T_OBJECT, value_field_idx, MemNode::unordered); |
4078 // String.value field is known to be @Stable. |
4084 // String.value field is known to be @Stable. |
4079 if (UseImplicitStableValues) { |
4085 if (UseImplicitStableValues) { |
4080 load = cast_array_to_stable(load, value_type); |
4086 load = cast_array_to_stable(load, value_type); |
4081 } |
4087 } |
4082 return load; |
4088 return load; |
4087 const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(), |
4093 const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(), |
4088 false, NULL, 0); |
4094 false, NULL, 0); |
4089 const TypePtr* offset_field_type = string_type->add_offset(offset_offset); |
4095 const TypePtr* offset_field_type = string_type->add_offset(offset_offset); |
4090 int offset_field_idx = C->get_alias_index(offset_field_type); |
4096 int offset_field_idx = C->get_alias_index(offset_field_type); |
4091 store_to_memory(ctrl, basic_plus_adr(str, offset_offset), |
4097 store_to_memory(ctrl, basic_plus_adr(str, offset_offset), |
4092 value, T_INT, offset_field_idx); |
4098 value, T_INT, offset_field_idx, MemNode::unordered); |
4093 } |
4099 } |
4094 |
4100 |
4095 void GraphKit::store_String_value(Node* ctrl, Node* str, Node* value) { |
4101 void GraphKit::store_String_value(Node* ctrl, Node* str, Node* value) { |
4096 int value_offset = java_lang_String::value_offset_in_bytes(); |
4102 int value_offset = java_lang_String::value_offset_in_bytes(); |
4097 const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(), |
4103 const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(), |
4098 false, NULL, 0); |
4104 false, NULL, 0); |
4099 const TypePtr* value_field_type = string_type->add_offset(value_offset); |
4105 const TypePtr* value_field_type = string_type->add_offset(value_offset); |
4100 |
4106 |
4101 store_oop_to_object(ctrl, str, basic_plus_adr(str, value_offset), value_field_type, |
4107 store_oop_to_object(ctrl, str, basic_plus_adr(str, value_offset), value_field_type, |
4102 value, TypeAryPtr::CHARS, T_OBJECT); |
4108 value, TypeAryPtr::CHARS, T_OBJECT, MemNode::unordered); |
4103 } |
4109 } |
4104 |
4110 |
4105 void GraphKit::store_String_length(Node* ctrl, Node* str, Node* value) { |
4111 void GraphKit::store_String_length(Node* ctrl, Node* str, Node* value) { |
4106 int count_offset = java_lang_String::count_offset_in_bytes(); |
4112 int count_offset = java_lang_String::count_offset_in_bytes(); |
4107 const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(), |
4113 const TypeInstPtr* string_type = TypeInstPtr::make(TypePtr::NotNull, C->env()->String_klass(), |
4108 false, NULL, 0); |
4114 false, NULL, 0); |
4109 const TypePtr* count_field_type = string_type->add_offset(count_offset); |
4115 const TypePtr* count_field_type = string_type->add_offset(count_offset); |
4110 int count_field_idx = C->get_alias_index(count_field_type); |
4116 int count_field_idx = C->get_alias_index(count_field_type); |
4111 store_to_memory(ctrl, basic_plus_adr(str, count_offset), |
4117 store_to_memory(ctrl, basic_plus_adr(str, count_offset), |
4112 value, T_INT, count_field_idx); |
4118 value, T_INT, count_field_idx, MemNode::unordered); |
4113 } |
4119 } |
4114 |
4120 |
4115 Node* GraphKit::cast_array_to_stable(Node* ary, const TypeAryPtr* ary_type) { |
4121 Node* GraphKit::cast_array_to_stable(Node* ary, const TypeAryPtr* ary_type) { |
4116 // Reify the property as a CastPP node in Ideal graph to comply with monotonicity |
4122 // Reify the property as a CastPP node in Ideal graph to comply with monotonicity |
4117 // assumption of CCP analysis. |
4123 // assumption of CCP analysis. |