55 const TypeLong* lidxtype = TypeLong::make(CONST64(0), index_max, Type::WidenMax);
56 idx = transform_later( new ConvI2LNode(idx, lidxtype) );
57 #endif
58 Node* scale = new LShiftXNode(idx, intcon(shift));
59 transform_later(scale);
60 return basic_plus_adr(ary, base, scale);
61 }
62
63 Node* PhaseMacroExpand::ConvI2L(Node* offset) {
64 return transform_later(new ConvI2LNode(offset));
65 }
66
67 Node* PhaseMacroExpand::make_leaf_call(Node* ctrl, Node* mem,
68 const TypeFunc* call_type, address call_addr,
69 const char* call_name,
70 const TypePtr* adr_type,
71 Node* parm0, Node* parm1,
72 Node* parm2, Node* parm3,
73 Node* parm4, Node* parm5,
74 Node* parm6, Node* parm7) {
75 int size = call_type->domain()->cnt();
76 Node* call = new CallLeafNoFPNode(call_type, call_addr, call_name, adr_type);
77 call->init_req(TypeFunc::Control, ctrl);
78 call->init_req(TypeFunc::I_O , top());
79 call->init_req(TypeFunc::Memory , mem);
80 call->init_req(TypeFunc::ReturnAdr, top());
81 call->init_req(TypeFunc::FramePtr, top());
82
83 // Hook each parm in order. Stop looking at the first NULL.
84 if (parm0 != NULL) { call->init_req(TypeFunc::Parms+0, parm0);
85 if (parm1 != NULL) { call->init_req(TypeFunc::Parms+1, parm1);
86 if (parm2 != NULL) { call->init_req(TypeFunc::Parms+2, parm2);
87 if (parm3 != NULL) { call->init_req(TypeFunc::Parms+3, parm3);
88 if (parm4 != NULL) { call->init_req(TypeFunc::Parms+4, parm4);
89 if (parm5 != NULL) { call->init_req(TypeFunc::Parms+5, parm5);
90 if (parm6 != NULL) { call->init_req(TypeFunc::Parms+6, parm6);
91 if (parm7 != NULL) { call->init_req(TypeFunc::Parms+7, parm7);
92 /* close each nested if ===> */ } } } } } } } }
93 assert(call->in(call->req()-1) != NULL, "must initialize all parms");
94
95 return call;
1090 Node* src_offset = ac->in(ArrayCopyNode::SrcPos);
1091 Node* dest = ac->in(ArrayCopyNode::Dest);
1092 Node* dest_offset = ac->in(ArrayCopyNode::DestPos);
1093 Node* length = ac->in(ArrayCopyNode::Length);
1094 MergeMemNode* merge_mem = NULL;
1095
1096 if (ac->is_clonebasic()) {
1097 assert (src_offset == NULL && dest_offset == NULL, "for clone offsets should be null");
1098 Node* mem = ac->in(TypeFunc::Memory);
1099 const char* copyfunc_name = "arraycopy";
1100 address copyfunc_addr =
1101 basictype2arraycopy(T_LONG, NULL, NULL,
1102 true, copyfunc_name, true);
1103
1104 const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
1105 const TypeFunc* call_type = OptoRuntime::fast_arraycopy_Type();
1106
1107 Node* call = make_leaf_call(ctrl, mem, call_type, copyfunc_addr, copyfunc_name, raw_adr_type, src, dest, length XTOP);
1108 transform_later(call);
1109
1110 _igvn.replace_node(ac, call);
1111 return;
1112 } else if (ac->is_copyof() || ac->is_copyofrange() || ac->is_cloneoop()) {
1113 Node* mem = ac->in(TypeFunc::Memory);
1114 merge_mem = MergeMemNode::make(mem);
1115 transform_later(merge_mem);
1116
1117 RegionNode* slow_region = new RegionNode(1);
1118 transform_later(slow_region);
1119
1120 AllocateArrayNode* alloc = NULL;
1121 if (ac->is_alloc_tightly_coupled()) {
1122 alloc = AllocateArrayNode::Ideal_array_allocation(dest, &_igvn);
1123 assert(alloc != NULL, "expect alloc");
1124 }
1125
1126 const TypePtr* adr_type = _igvn.type(dest)->is_oopptr()->add_offset(Type::OffsetBot);
1127 if (ac->_dest_type != TypeOopPtr::BOTTOM) {
1128 adr_type = ac->_dest_type->add_offset(Type::OffsetBot)->is_ptr();
1129 }
1130 generate_arraycopy(ac, alloc, &ctrl, merge_mem, &io,
|
55 const TypeLong* lidxtype = TypeLong::make(CONST64(0), index_max, Type::WidenMax);
56 idx = transform_later( new ConvI2LNode(idx, lidxtype) );
57 #endif
58 Node* scale = new LShiftXNode(idx, intcon(shift));
59 transform_later(scale);
60 return basic_plus_adr(ary, base, scale);
61 }
62
63 Node* PhaseMacroExpand::ConvI2L(Node* offset) {
64 return transform_later(new ConvI2LNode(offset));
65 }
66
67 Node* PhaseMacroExpand::make_leaf_call(Node* ctrl, Node* mem,
68 const TypeFunc* call_type, address call_addr,
69 const char* call_name,
70 const TypePtr* adr_type,
71 Node* parm0, Node* parm1,
72 Node* parm2, Node* parm3,
73 Node* parm4, Node* parm5,
74 Node* parm6, Node* parm7) {
75 Node* call = new CallLeafNoFPNode(call_type, call_addr, call_name, adr_type);
76 call->init_req(TypeFunc::Control, ctrl);
77 call->init_req(TypeFunc::I_O , top());
78 call->init_req(TypeFunc::Memory , mem);
79 call->init_req(TypeFunc::ReturnAdr, top());
80 call->init_req(TypeFunc::FramePtr, top());
81
82 // Hook each parm in order. Stop looking at the first NULL.
83 if (parm0 != NULL) { call->init_req(TypeFunc::Parms+0, parm0);
84 if (parm1 != NULL) { call->init_req(TypeFunc::Parms+1, parm1);
85 if (parm2 != NULL) { call->init_req(TypeFunc::Parms+2, parm2);
86 if (parm3 != NULL) { call->init_req(TypeFunc::Parms+3, parm3);
87 if (parm4 != NULL) { call->init_req(TypeFunc::Parms+4, parm4);
88 if (parm5 != NULL) { call->init_req(TypeFunc::Parms+5, parm5);
89 if (parm6 != NULL) { call->init_req(TypeFunc::Parms+6, parm6);
90 if (parm7 != NULL) { call->init_req(TypeFunc::Parms+7, parm7);
91 /* close each nested if ===> */ } } } } } } } }
92 assert(call->in(call->req()-1) != NULL, "must initialize all parms");
93
94 return call;
1089 Node* src_offset = ac->in(ArrayCopyNode::SrcPos);
1090 Node* dest = ac->in(ArrayCopyNode::Dest);
1091 Node* dest_offset = ac->in(ArrayCopyNode::DestPos);
1092 Node* length = ac->in(ArrayCopyNode::Length);
1093 MergeMemNode* merge_mem = NULL;
1094
1095 if (ac->is_clonebasic()) {
1096 assert (src_offset == NULL && dest_offset == NULL, "for clone offsets should be null");
1097 Node* mem = ac->in(TypeFunc::Memory);
1098 const char* copyfunc_name = "arraycopy";
1099 address copyfunc_addr =
1100 basictype2arraycopy(T_LONG, NULL, NULL,
1101 true, copyfunc_name, true);
1102
1103 const TypePtr* raw_adr_type = TypeRawPtr::BOTTOM;
1104 const TypeFunc* call_type = OptoRuntime::fast_arraycopy_Type();
1105
1106 Node* call = make_leaf_call(ctrl, mem, call_type, copyfunc_addr, copyfunc_name, raw_adr_type, src, dest, length XTOP);
1107 transform_later(call);
1108
1109 BarrierSetC2* bs = BarrierSet::barrier_set()->barrier_set_c2();
1110 bs->clone_barrier_at_expansion(ac, call, _igvn);
1111
1112 return;
1113 } else if (ac->is_copyof() || ac->is_copyofrange() || ac->is_cloneoop()) {
1114 Node* mem = ac->in(TypeFunc::Memory);
1115 merge_mem = MergeMemNode::make(mem);
1116 transform_later(merge_mem);
1117
1118 RegionNode* slow_region = new RegionNode(1);
1119 transform_later(slow_region);
1120
1121 AllocateArrayNode* alloc = NULL;
1122 if (ac->is_alloc_tightly_coupled()) {
1123 alloc = AllocateArrayNode::Ideal_array_allocation(dest, &_igvn);
1124 assert(alloc != NULL, "expect alloc");
1125 }
1126
1127 const TypePtr* adr_type = _igvn.type(dest)->is_oopptr()->add_offset(Type::OffsetBot);
1128 if (ac->_dest_type != TypeOopPtr::BOTTOM) {
1129 adr_type = ac->_dest_type->add_offset(Type::OffsetBot)->is_ptr();
1130 }
1131 generate_arraycopy(ac, alloc, &ctrl, merge_mem, &io,
|