1563 tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,aklass,false,Type::Offset(offset), ta->field_offset());
1564 }
1565 // During the 2nd round of IterGVN, NotNull castings are removed.
1566 // Make sure the Bottom and NotNull variants alias the same.
1567 // Also, make sure exact and non-exact variants alias the same.
1568 if (ptr == TypePtr::NotNull || ta->klass_is_exact() || ta->speculative() != NULL) {
1569 tj = ta = TypeAryPtr::make(TypePtr::BotPTR,ta->ary(),ta->klass(),false,Type::Offset(offset), ta->field_offset());
1570 }
1571 }
1572
1573 // Oop pointers need some flattening
1574 const TypeInstPtr *to = tj->isa_instptr();
1575 if( to && _AliasLevel >= 2 && to != TypeOopPtr::BOTTOM ) {
1576 ciInstanceKlass *k = to->klass()->as_instance_klass();
1577 if( ptr == TypePtr::Constant ) {
1578 if (to->klass() != ciEnv::current()->Class_klass() ||
1579 offset < k->size_helper() * wordSize) {
1580 // No constant oop pointers (such as Strings); they alias with
1581 // unknown strings.
1582 assert(!is_known_inst, "not scalarizable allocation");
1583 tj = to = TypeInstPtr::make(TypePtr::BotPTR,to->klass(),false,0,Type::Offset(offset));
1584 }
1585 } else if( is_known_inst ) {
1586 tj = to; // Keep NotNull and klass_is_exact for instance type
1587 } else if( ptr == TypePtr::NotNull || to->klass_is_exact() ) {
1588 // During the 2nd round of IterGVN, NotNull castings are removed.
1589 // Make sure the Bottom and NotNull variants alias the same.
1590 // Also, make sure exact and non-exact variants alias the same.
1591 tj = to = TypeInstPtr::make(TypePtr::BotPTR,to->klass(),false,0,Type::Offset(offset));
1592 }
1593 if (to->speculative() != NULL) {
1594 tj = to = TypeInstPtr::make(to->ptr(),to->klass(),to->klass_is_exact(),to->const_oop(),Type::Offset(to->offset()), to->instance_id());
1595 }
1596 // Canonicalize the holder of this field
1597 if (offset >= 0 && offset < instanceOopDesc::base_offset_in_bytes()) {
1598 // First handle header references such as a LoadKlassNode, even if the
1599 // object's klass is unloaded at compile time (4965979).
1600 if (!is_known_inst) { // Do it only for non-instance types
1601 tj = to = TypeInstPtr::make(TypePtr::BotPTR, env()->Object_klass(), false, NULL, Type::Offset(offset));
1602 }
1603 } else if (BarrierSet::barrier_set()->barrier_set_c2()->flatten_gc_alias_type(tj)) {
1604 to = tj->is_instptr();
1605 } else if (offset < 0 || offset >= k->size_helper() * wordSize) {
1606 // Static fields are in the space above the normal instance
1607 // fields in the java.lang.Class instance.
1608 if (to->klass() != ciEnv::current()->Class_klass()) {
1609 to = NULL;
1610 tj = TypeOopPtr::BOTTOM;
1611 offset = tj->offset();
1612 }
1613 } else {
1614 ciInstanceKlass *canonical_holder = k->get_canonical_holder(offset);
1615 if (!k->equals(canonical_holder) || tj->offset() != offset) {
1616 if( is_known_inst ) {
1617 tj = to = TypeInstPtr::make(to->ptr(), canonical_holder, true, NULL, Type::Offset(offset), to->instance_id());
1618 } else {
1619 tj = to = TypeInstPtr::make(to->ptr(), canonical_holder, false, NULL, Type::Offset(offset));
1620 }
1621 }
1622 }
1623 }
1624
1625 // Klass pointers to object array klasses need some flattening
1626 const TypeKlassPtr *tk = tj->isa_klassptr();
1627 if( tk ) {
1628 // If we are referencing a field within a Klass, we need
1629 // to assume the worst case of an Object. Both exact and
1630 // inexact types must flatten to the same alias class so
1631 // use NotNull as the PTR.
1632 if ( offset == Type::OffsetBot || (offset >= 0 && (size_t)offset < sizeof(Klass)) ) {
1633
1634 tj = tk = TypeKlassPtr::make(TypePtr::NotNull,
1635 TypeKlassPtr::OBJECT->klass(),
1636 Type::Offset(offset));
1637 }
1638
1639 ciKlass* klass = tk->klass();
1640 if (klass != NULL && klass->is_obj_array_klass()) {
1641 ciKlass* k = TypeAryPtr::OOPS->klass();
1642 if( !k || !k->is_loaded() ) // Only fails for some -Xcomp runs
1643 k = TypeInstPtr::BOTTOM->klass();
1644 tj = tk = TypeKlassPtr::make(TypePtr::NotNull, k, Type::Offset(offset));
1645 }
1646
1647 // Check for precise loads from the primary supertype array and force them
1648 // to the supertype cache alias index. Check for generic array loads from
1649 // the primary supertype array and also force them to the supertype cache
1650 // alias index. Since the same load can reach both, we need to merge
1651 // these 2 disparate memories into the same alias class. Since the
1652 // primary supertype array is read-only, there's no chance of confusion
1653 // where we bypass an array load and an array store.
1654 int primary_supers_offset = in_bytes(Klass::primary_supers_offset());
1655 if (offset == Type::OffsetBot ||
1656 (offset >= primary_supers_offset &&
1657 offset < (int)(primary_supers_offset + Klass::primary_super_limit() * wordSize)) ||
1658 offset == (int)in_bytes(Klass::secondary_super_cache_offset())) {
1659 offset = in_bytes(Klass::secondary_super_cache_offset());
1660 tj = tk = TypeKlassPtr::make(TypePtr::NotNull, tk->klass(), Type::Offset(offset));
1661 }
1662 }
1663
1664 // Flatten all Raw pointers together.
1665 if (tj->base() == Type::RawPtr)
1666 tj = TypeRawPtr::BOTTOM;
1667
1668 if (tj->base() == Type::AnyPtr)
1669 tj = TypePtr::BOTTOM; // An error, which the caller must check for.
1670
1671 // Flatten all to bottom for now
1672 switch( _AliasLevel ) {
1673 case 0:
1674 tj = TypePtr::BOTTOM;
1675 break;
1676 case 1: // Flatten to: oop, static, field or array
1677 switch (tj->base()) {
1678 //case Type::AryPtr: tj = TypeAryPtr::RANGE; break;
1679 case Type::RawPtr: tj = TypeRawPtr::BOTTOM; break;
1680 case Type::AryPtr: // do not distinguish arrays at all
3420 case Op_LoadNKlass:
3421 case Op_LoadL:
3422 case Op_LoadL_unaligned:
3423 case Op_LoadPLocked:
3424 case Op_LoadP:
3425 case Op_LoadN:
3426 case Op_LoadRange:
3427 case Op_LoadS: {
3428 handle_mem:
3429 #ifdef ASSERT
3430 if( VerifyOptoOopOffsets ) {
3431 MemNode* mem = n->as_Mem();
3432 // Check to see if address types have grounded out somehow.
3433 const TypeInstPtr *tp = mem->in(MemNode::Address)->bottom_type()->isa_instptr();
3434 assert( !tp || oop_offset_is_sane(tp), "" );
3435 }
3436 #endif
3437 if (EnableValhalla && (nop == Op_LoadKlass || nop == Op_LoadNKlass)) {
3438 const TypeKlassPtr* tk = n->bottom_type()->make_ptr()->is_klassptr();
3439 assert(!tk->klass_is_exact(), "should have been folded");
3440 if (tk->klass()->can_be_value_array_klass()) {
3441 // Array load klass needs to filter out property bits (but not
3442 // GetNullFreePropertyNode which needs to extract the null free bits)
3443 uint last = unique();
3444 Node* pointer = NULL;
3445 if (nop == Op_LoadKlass) {
3446 Node* cast = new CastP2XNode(NULL, n);
3447 Node* masked = new LShiftXNode(cast, new ConINode(TypeInt::make(oopDesc::storage_props_nof_bits)));
3448 masked = new RShiftXNode(masked, new ConINode(TypeInt::make(oopDesc::storage_props_nof_bits)));
3449 pointer = new CastX2PNode(masked);
3450 pointer = new CheckCastPPNode(NULL, pointer, n->bottom_type());
3451 } else {
3452 Node* cast = new CastN2INode(n);
3453 Node* masked = new AndINode(cast, new ConINode(TypeInt::make(oopDesc::compressed_klass_mask())));
3454 pointer = new CastI2NNode(masked, n->bottom_type());
3455 }
3456 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
3457 Node* u = n->fast_out(i);
3458 if (u->_idx < last && u->Opcode() != Op_GetNullFreeProperty) {
3459 // If user is a comparison with a klass that can't be a value type
3460 // array klass, we don't need to clear the storage property bits.
3461 Node* cmp = (u->is_DecodeNKlass() && u->outcnt() == 1) ? u->unique_out() : u;
3462 if (cmp->is_Cmp()) {
3463 const TypeKlassPtr* kp1 = cmp->in(1)->bottom_type()->make_ptr()->isa_klassptr();
3464 const TypeKlassPtr* kp2 = cmp->in(2)->bottom_type()->make_ptr()->isa_klassptr();
3465 if ((kp1 != NULL && !kp1->klass()->can_be_value_array_klass()) ||
3466 (kp2 != NULL && !kp2->klass()->can_be_value_array_klass())) {
3467 continue;
3468 }
3469 }
3470 int nb = u->replace_edge(n, pointer);
3471 --i, imax -= nb;
3472 }
3473 }
3474 }
3475 }
3476 break;
3477 }
3478
3978 if (!Matcher::has_match_rule(Op_CmpUL)) {
3979 // No support for unsigned long comparisons
3980 ConINode* sign_pos = new ConINode(TypeInt::make(BitsPerLong - 1));
3981 Node* sign_bit_mask = new RShiftLNode(n->in(1), sign_pos);
3982 Node* orl = new OrLNode(n->in(1), sign_bit_mask);
3983 ConLNode* remove_sign_mask = new ConLNode(TypeLong::make(max_jlong));
3984 Node* andl = new AndLNode(orl, remove_sign_mask);
3985 Node* cmp = new CmpLNode(andl, n->in(2));
3986 n->subsume_by(cmp, this);
3987 }
3988 break;
3989 }
3990 #ifdef ASSERT
3991 case Op_ValueTypePtr:
3992 case Op_ValueType: {
3993 n->dump(-1);
3994 assert(false, "value type node was not removed");
3995 break;
3996 }
3997 #endif
3998 case Op_GetNullFreeProperty: {
3999 // Extract the null free bits
4000 uint last = unique();
4001 Node* null_free = NULL;
4002 if (n->in(1)->Opcode() == Op_LoadKlass) {
4003 Node* cast = new CastP2XNode(NULL, n->in(1));
4004 null_free = new AndLNode(cast, new ConLNode(TypeLong::make(((jlong)1)<<(oopDesc::wide_storage_props_shift + ArrayStorageProperties::null_free_bit))));
4005 } else {
4006 assert(n->in(1)->Opcode() == Op_LoadNKlass, "not a compressed klass?");
4007 Node* cast = new CastN2INode(n->in(1));
4008 null_free = new AndINode(cast, new ConINode(TypeInt::make(1<<(oopDesc::narrow_storage_props_shift + ArrayStorageProperties::null_free_bit))));
4009 }
4010 n->replace_by(null_free);
4011 break;
4012 }
4013 default:
4014 assert(!n->is_Call(), "");
4015 assert(!n->is_Mem(), "");
4016 assert(nop != Op_ProfileBoolean, "should be eliminated during IGVN");
4017 break;
4018 }
4019 }
4020
4021 //------------------------------final_graph_reshaping_walk---------------------
4022 // Replacing Opaque nodes with their input in final_graph_reshaping_impl(),
4023 // requires that the walk visits a node's inputs before visiting the node.
4024 void Compile::final_graph_reshaping_walk( Node_Stack &nstack, Node *root, Final_Reshape_Counts &frc ) {
4025 ResourceArea *area = Thread::current()->resource_area();
4026 Unique_Node_List sfpt(area);
4027
4028 frc._visited.set(root->_idx); // first, mark node as visited
4029 uint cnt = root->req();
4030 Node *n = root;
|
1563 tj = ta = TypeAryPtr::make(ptr,ta->const_oop(),tary,aklass,false,Type::Offset(offset), ta->field_offset());
1564 }
1565 // During the 2nd round of IterGVN, NotNull castings are removed.
1566 // Make sure the Bottom and NotNull variants alias the same.
1567 // Also, make sure exact and non-exact variants alias the same.
1568 if (ptr == TypePtr::NotNull || ta->klass_is_exact() || ta->speculative() != NULL) {
1569 tj = ta = TypeAryPtr::make(TypePtr::BotPTR,ta->ary(),ta->klass(),false,Type::Offset(offset), ta->field_offset());
1570 }
1571 }
1572
1573 // Oop pointers need some flattening
1574 const TypeInstPtr *to = tj->isa_instptr();
1575 if( to && _AliasLevel >= 2 && to != TypeOopPtr::BOTTOM ) {
1576 ciInstanceKlass *k = to->klass()->as_instance_klass();
1577 if( ptr == TypePtr::Constant ) {
1578 if (to->klass() != ciEnv::current()->Class_klass() ||
1579 offset < k->size_helper() * wordSize) {
1580 // No constant oop pointers (such as Strings); they alias with
1581 // unknown strings.
1582 assert(!is_known_inst, "not scalarizable allocation");
1583 tj = to = TypeInstPtr::make(TypePtr::BotPTR,to->klass(),false,0,Type::Offset(offset), to->klass()->flatten_array());
1584 }
1585 } else if( is_known_inst ) {
1586 tj = to; // Keep NotNull and klass_is_exact for instance type
1587 } else if( ptr == TypePtr::NotNull || to->klass_is_exact() ) {
1588 // During the 2nd round of IterGVN, NotNull castings are removed.
1589 // Make sure the Bottom and NotNull variants alias the same.
1590 // Also, make sure exact and non-exact variants alias the same.
1591 tj = to = TypeInstPtr::make(TypePtr::BotPTR,to->klass(),false,0,Type::Offset(offset), to->klass()->flatten_array());
1592 }
1593 if (to->speculative() != NULL) {
1594 tj = to = TypeInstPtr::make(to->ptr(),to->klass(),to->klass_is_exact(),to->const_oop(),Type::Offset(to->offset()), to->klass()->flatten_array(), to->instance_id());
1595 }
1596 // Canonicalize the holder of this field
1597 if (offset >= 0 && offset < instanceOopDesc::base_offset_in_bytes()) {
1598 // First handle header references such as a LoadKlassNode, even if the
1599 // object's klass is unloaded at compile time (4965979).
1600 if (!is_known_inst) { // Do it only for non-instance types
1601 tj = to = TypeInstPtr::make(TypePtr::BotPTR, env()->Object_klass(), false, NULL, Type::Offset(offset), false);
1602 }
1603 } else if (BarrierSet::barrier_set()->barrier_set_c2()->flatten_gc_alias_type(tj)) {
1604 to = tj->is_instptr();
1605 } else if (offset < 0 || offset >= k->size_helper() * wordSize) {
1606 // Static fields are in the space above the normal instance
1607 // fields in the java.lang.Class instance.
1608 if (to->klass() != ciEnv::current()->Class_klass()) {
1609 to = NULL;
1610 tj = TypeOopPtr::BOTTOM;
1611 offset = tj->offset();
1612 }
1613 } else {
1614 ciInstanceKlass *canonical_holder = k->get_canonical_holder(offset);
1615 if (!k->equals(canonical_holder) || tj->offset() != offset) {
1616 if( is_known_inst ) {
1617 tj = to = TypeInstPtr::make(to->ptr(), canonical_holder, true, NULL, Type::Offset(offset), canonical_holder->flatten_array(), to->instance_id());
1618 } else {
1619 tj = to = TypeInstPtr::make(to->ptr(), canonical_holder, false, NULL, Type::Offset(offset), canonical_holder->flatten_array());
1620 }
1621 }
1622 }
1623 }
1624
1625 // Klass pointers to object array klasses need some flattening
1626 const TypeKlassPtr *tk = tj->isa_klassptr();
1627 if( tk ) {
1628 // If we are referencing a field within a Klass, we need
1629 // to assume the worst case of an Object. Both exact and
1630 // inexact types must flatten to the same alias class so
1631 // use NotNull as the PTR.
1632 if ( offset == Type::OffsetBot || (offset >= 0 && (size_t)offset < sizeof(Klass)) ) {
1633
1634 tj = tk = TypeKlassPtr::make(TypePtr::NotNull,
1635 TypeKlassPtr::OBJECT->klass(),
1636 Type::Offset(offset),
1637 false);
1638 }
1639
1640 ciKlass* klass = tk->klass();
1641 if (klass != NULL && klass->is_obj_array_klass()) {
1642 ciKlass* k = TypeAryPtr::OOPS->klass();
1643 if( !k || !k->is_loaded() ) // Only fails for some -Xcomp runs
1644 k = TypeInstPtr::BOTTOM->klass();
1645 tj = tk = TypeKlassPtr::make(TypePtr::NotNull, k, Type::Offset(offset), false);
1646 }
1647
1648 // Check for precise loads from the primary supertype array and force them
1649 // to the supertype cache alias index. Check for generic array loads from
1650 // the primary supertype array and also force them to the supertype cache
1651 // alias index. Since the same load can reach both, we need to merge
1652 // these 2 disparate memories into the same alias class. Since the
1653 // primary supertype array is read-only, there's no chance of confusion
1654 // where we bypass an array load and an array store.
1655 int primary_supers_offset = in_bytes(Klass::primary_supers_offset());
1656 if (offset == Type::OffsetBot ||
1657 (offset >= primary_supers_offset &&
1658 offset < (int)(primary_supers_offset + Klass::primary_super_limit() * wordSize)) ||
1659 offset == (int)in_bytes(Klass::secondary_super_cache_offset())) {
1660 offset = in_bytes(Klass::secondary_super_cache_offset());
1661 tj = tk = TypeKlassPtr::make(TypePtr::NotNull, tk->klass(), Type::Offset(offset), tk->flatten_array());
1662 }
1663 }
1664
1665 // Flatten all Raw pointers together.
1666 if (tj->base() == Type::RawPtr)
1667 tj = TypeRawPtr::BOTTOM;
1668
1669 if (tj->base() == Type::AnyPtr)
1670 tj = TypePtr::BOTTOM; // An error, which the caller must check for.
1671
1672 // Flatten all to bottom for now
1673 switch( _AliasLevel ) {
1674 case 0:
1675 tj = TypePtr::BOTTOM;
1676 break;
1677 case 1: // Flatten to: oop, static, field or array
1678 switch (tj->base()) {
1679 //case Type::AryPtr: tj = TypeAryPtr::RANGE; break;
1680 case Type::RawPtr: tj = TypeRawPtr::BOTTOM; break;
1681 case Type::AryPtr: // do not distinguish arrays at all
3421 case Op_LoadNKlass:
3422 case Op_LoadL:
3423 case Op_LoadL_unaligned:
3424 case Op_LoadPLocked:
3425 case Op_LoadP:
3426 case Op_LoadN:
3427 case Op_LoadRange:
3428 case Op_LoadS: {
3429 handle_mem:
3430 #ifdef ASSERT
3431 if( VerifyOptoOopOffsets ) {
3432 MemNode* mem = n->as_Mem();
3433 // Check to see if address types have grounded out somehow.
3434 const TypeInstPtr *tp = mem->in(MemNode::Address)->bottom_type()->isa_instptr();
3435 assert( !tp || oop_offset_is_sane(tp), "" );
3436 }
3437 #endif
3438 if (EnableValhalla && (nop == Op_LoadKlass || nop == Op_LoadNKlass)) {
3439 const TypeKlassPtr* tk = n->bottom_type()->make_ptr()->is_klassptr();
3440 assert(!tk->klass_is_exact(), "should have been folded");
3441 if (tk->klass()->can_be_value_array_klass() && n->as_Mem()->adr_type()->offset() == oopDesc::klass_offset_in_bytes()) {
3442 // Array load klass needs to filter out property bits (but not
3443 // GetNullFreePropertyNode or GetFlattenedPropertyNode which
3444 // needs to extract the storage property bits)
3445 uint last = unique();
3446 Node* pointer = NULL;
3447 if (nop == Op_LoadKlass) {
3448 Node* cast = new CastP2XNode(NULL, n);
3449 Node* masked = new LShiftXNode(cast, new ConINode(TypeInt::make(oopDesc::storage_props_nof_bits)));
3450 masked = new RShiftXNode(masked, new ConINode(TypeInt::make(oopDesc::storage_props_nof_bits)));
3451 pointer = new CastX2PNode(masked);
3452 pointer = new CheckCastPPNode(NULL, pointer, n->bottom_type());
3453 } else {
3454 Node* cast = new CastN2INode(n);
3455 Node* masked = new AndINode(cast, new ConINode(TypeInt::make(oopDesc::compressed_klass_mask())));
3456 pointer = new CastI2NNode(masked, n->bottom_type());
3457 }
3458 for (DUIterator_Fast imax, i = n->fast_outs(imax); i < imax; i++) {
3459 Node* u = n->fast_out(i);
3460 if (u->_idx < last && u->Opcode() != Op_GetNullFreeProperty && u->Opcode() != Op_GetFlattenedProperty) {
3461 // If user is a comparison with a klass that can't be a value type
3462 // array klass, we don't need to clear the storage property bits.
3463 Node* cmp = (u->is_DecodeNKlass() && u->outcnt() == 1) ? u->unique_out() : u;
3464 if (cmp->is_Cmp()) {
3465 const TypeKlassPtr* kp1 = cmp->in(1)->bottom_type()->make_ptr()->isa_klassptr();
3466 const TypeKlassPtr* kp2 = cmp->in(2)->bottom_type()->make_ptr()->isa_klassptr();
3467 if ((kp1 != NULL && !kp1->klass()->can_be_value_array_klass()) ||
3468 (kp2 != NULL && !kp2->klass()->can_be_value_array_klass())) {
3469 continue;
3470 }
3471 }
3472 int nb = u->replace_edge(n, pointer);
3473 --i, imax -= nb;
3474 }
3475 }
3476 }
3477 }
3478 break;
3479 }
3480
3980 if (!Matcher::has_match_rule(Op_CmpUL)) {
3981 // No support for unsigned long comparisons
3982 ConINode* sign_pos = new ConINode(TypeInt::make(BitsPerLong - 1));
3983 Node* sign_bit_mask = new RShiftLNode(n->in(1), sign_pos);
3984 Node* orl = new OrLNode(n->in(1), sign_bit_mask);
3985 ConLNode* remove_sign_mask = new ConLNode(TypeLong::make(max_jlong));
3986 Node* andl = new AndLNode(orl, remove_sign_mask);
3987 Node* cmp = new CmpLNode(andl, n->in(2));
3988 n->subsume_by(cmp, this);
3989 }
3990 break;
3991 }
3992 #ifdef ASSERT
3993 case Op_ValueTypePtr:
3994 case Op_ValueType: {
3995 n->dump(-1);
3996 assert(false, "value type node was not removed");
3997 break;
3998 }
3999 #endif
4000 case Op_GetNullFreeProperty:
4001 case Op_GetFlattenedProperty: {
4002 // Extract the null free bits
4003 uint last = unique();
4004 Node* null_free = NULL;
4005 int bit = nop == Op_GetNullFreeProperty ? ArrayStorageProperties::null_free_bit : ArrayStorageProperties::flattened_bit;
4006 if (n->in(1)->Opcode() == Op_LoadKlass) {
4007 Node* cast = new CastP2XNode(NULL, n->in(1));
4008 null_free = new AndLNode(cast, new ConLNode(TypeLong::make(((jlong)1)<<(oopDesc::wide_storage_props_shift + bit))));
4009 } else {
4010 assert(n->in(1)->Opcode() == Op_LoadNKlass, "not a compressed klass?");
4011 Node* cast = new CastN2INode(n->in(1));
4012 null_free = new AndINode(cast, new ConINode(TypeInt::make(1<<(oopDesc::narrow_storage_props_shift + bit))));
4013 }
4014 n->subsume_by(null_free, this);
4015 break;
4016 }
4017 default:
4018 assert(!n->is_Call(), "");
4019 assert(!n->is_Mem(), "");
4020 assert(nop != Op_ProfileBoolean, "should be eliminated during IGVN");
4021 break;
4022 }
4023 }
4024
4025 //------------------------------final_graph_reshaping_walk---------------------
4026 // Replacing Opaque nodes with their input in final_graph_reshaping_impl(),
4027 // requires that the walk visits a node's inputs before visiting the node.
4028 void Compile::final_graph_reshaping_walk( Node_Stack &nstack, Node *root, Final_Reshape_Counts &frc ) {
4029 ResourceArea *area = Thread::current()->resource_area();
4030 Unique_Node_List sfpt(area);
4031
4032 frc._visited.set(root->_idx); // first, mark node as visited
4033 uint cnt = root->req();
4034 Node *n = root;
|