vm/opto/memnode.cpp

628       InitializeNode* st_init = mem->in(0)->as_Initialize();
1037     // to find_captured_store, which returned InitializeNode::zero_memory.)
1050       InitializeNode* init = st->in(0)->as_Initialize();
2451     InitializeNode* init = mem->in(0)->as_Initialize();
2455       // If the InitializeNode captured me, it made a raw copy of me,
2507   // (It must already have been captured by the InitializeNode.)
2811   InitializeNode* init = alloc->initialization();
2931   case Op_Initialize:        return new InitializeNode(C, atp, pn);
3023 //===========================InitializeNode====================================
3051 // An InitializeNode collects and isolates object initialization after
3058 // The semantics of the InitializeNode include an implicit zeroing of
3062 // Certain stores may be added as direct inputs to the InitializeNode.
3071 // (See comments in InitializeNode::capture_store, which continue
3074 // When the associated Allocate is macro-expanded, the InitializeNode
3077 // The InitializeNode is then marked 'complete', prohibiting further
3090 // InitializeNode, to perform arbitrary initialization of the new object.
3095 // While an InitializeNode is incomplete, reads from the memory state
3101 // InitializeNode.  It is cloned as a raw memory operation and rewired
3111 // will be considered for capture by an InitializeNode.  This puts a
3114 //---------------------------InitializeNode------------------------------------
3115 InitializeNode::InitializeNode(Compile* C, int adr_type, Node* rawoop)
3129 const RegMask &InitializeNode::in_RegMask(uint idx) const {
3131   if (idx == InitializeNode::RawAddress)
3136 Node* InitializeNode::memory(uint alias_idx) {
3146 bool InitializeNode::is_non_zero() {
3152 void InitializeNode::set_complete(PhaseGVN* phase) {
3168   InitializeNode* init = initialization();
3177 void InitializeNode::remove_extra_zeroes() {
3194 intptr_t InitializeNode::get_store_offset(Node* st, PhaseTransform* phase) {
3210 bool InitializeNode::detect_init_independence(Node* n, int& count) {
3251 intptr_t InitializeNode::can_capture_store(StoreNode* st, PhaseTransform* phase, bool can_reshape) {
3303           // of the Store which is right after the InitializeNode then
3304           // this node cannot be between the InitializeNode and the
3311             // following the InitializeNode on the same slice as the
3327                 // after the InitializeNode. We check the control of the
3371 int InitializeNode::captured_store_insertion_point(intptr_t start,
3388   for (uint i = InitializeNode::RawStores, limit = req(); ; ) {
3425 Node* InitializeNode::find_captured_store(intptr_t start, int size_in_bytes,
3441 Node* InitializeNode::make_raw_address(intptr_t offset,
3457 // From the example above InitializeNode::InitializeNode,
3470 Node* InitializeNode::capture_store(StoreNode* st, intptr_t start,
3489     if (i > InitializeNode::RawStores && in(i-1) == prev_mem)
3538 // In terms of the running example on InitializeNode::InitializeNode
3539 // and InitializeNode::capture_store, here is the transformation
3548 InitializeNode::coalesce_subword_stores(intptr_t header_size,
3586   for (uint i = InitializeNode::RawStores, limit = req(); i < limit; i++) {
3751       if (ins_idx > InitializeNode::RawStores && in(ins_idx-1) == zmem)
3775 intptr_t InitializeNode::find_next_fullword_store(uint start, PhaseGVN* phase) {
3826 Node* InitializeNode::complete_stores(Node* rawctl, Node* rawmem, Node* rawptr,
3856   for (uint i = InitializeNode::RawStores, limit = req(); i < limit; i++) {
3981 bool InitializeNode::stores_are_sane(PhaseTransform* phase) {
3986   for (uint i = InitializeNode::RawStores; i < req(); i++) {