Lines Matching refs:InitializeNode
549 InitializeNode* st_init = mem->in(0)->as_Initialize();
1033 // to find_captured_store, which returned InitializeNode::zero_memory.)
1046 InitializeNode* init = st->in(0)->as_Initialize();
2335 InitializeNode* init = mem->in(0)->as_Initialize();
2339 // If the InitializeNode captured me, it made a raw copy of me,
2391 // (It must already have been captured by the InitializeNode.)
2689 InitializeNode* init = alloc->initialization();
2842 case Op_Initialize: return new(C) InitializeNode(C, atp, pn);
2917 //===========================InitializeNode====================================
2945 // An InitializeNode collects and isolates object initialization after
2952 // The semantics of the InitializeNode include an implicit zeroing of
2956 // Certain stores may be added as direct inputs to the InitializeNode.
2965 // (See comments in InitializeNode::capture_store, which continue
2968 // When the associated Allocate is macro-expanded, the InitializeNode
2971 // The InitializeNode is then marked 'complete', prohibiting further
2984 // InitializeNode, to perform arbitrary initialization of the new object.
2989 // While an InitializeNode is incomplete, reads from the memory state
2995 // InitializeNode. It is cloned as a raw memory operation and rewired
3005 // will be considered for capture by an InitializeNode. This puts a
3008 //---------------------------InitializeNode------------------------------------
3009 InitializeNode::InitializeNode(Compile* C, int adr_type, Node* rawoop)
3023 const RegMask &InitializeNode::in_RegMask(uint idx) const {
3025 if (idx == InitializeNode::RawAddress)
3030 Node* InitializeNode::memory(uint alias_idx) {
3040 bool InitializeNode::is_non_zero() {
3046 void InitializeNode::set_complete(PhaseGVN* phase) {
3062 InitializeNode* init = initialization();
3071 void InitializeNode::remove_extra_zeroes() {
3088 intptr_t InitializeNode::get_store_offset(Node* st, PhaseTransform* phase) {
3104 bool InitializeNode::detect_init_independence(Node* n,
3148 intptr_t InitializeNode::can_capture_store(StoreNode* st, PhaseTransform* phase, bool can_reshape) {
3197 // of the Store which is right after the InitializeNode then
3198 // this node cannot be between the InitializeNode and the
3205 // following the InitializeNode on the same slice as the
3221 // after the InitializeNode. We check the control of the
3265 int InitializeNode::captured_store_insertion_point(intptr_t start,
3282 for (uint i = InitializeNode::RawStores, limit = req(); ; ) {
3319 Node* InitializeNode::find_captured_store(intptr_t start, int size_in_bytes,
3335 Node* InitializeNode::make_raw_address(intptr_t offset,
3351 // From the example above InitializeNode::InitializeNode,
3364 Node* InitializeNode::capture_store(StoreNode* st, intptr_t start,
3383 if (i > InitializeNode::RawStores && in(i-1) == prev_mem)
3431 // In terms of the running example on InitializeNode::InitializeNode
3432 // and InitializeNode::capture_store, here is the transformation
3441 InitializeNode::coalesce_subword_stores(intptr_t header_size,
3479 for (uint i = InitializeNode::RawStores, limit = req(); i < limit; i++) {
3644 if (ins_idx > InitializeNode::RawStores && in(ins_idx-1) == zmem)
3668 intptr_t InitializeNode::find_next_fullword_store(uint start, PhaseGVN* phase) {
3719 Node* InitializeNode::complete_stores(Node* rawctl, Node* rawmem, Node* rawptr,
3749 for (uint i = InitializeNode::RawStores, limit = req(); i < limit; i++) {
3873 bool InitializeNode::stores_are_sane(PhaseTransform* phase) {
3878 for (uint i = InitializeNode::RawStores; i < req(); i++) {