< prev index next >

src/hotspot/share/opto/macroArrayCopy.cpp

Print this page




  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,


< prev index next >