Lines Matching refs:memory
28 #include "memory/allocation.inline.hpp"
118 // skip over a call which does not affect this memory slice
131 // which contains this memory slice, otherwise skip over it.
162 assert(mphi->bottom_type() == Type::MEMORY, "memory phi required");
172 assert(phase->C->get_alias_index(t) == phase->C->get_alias_index(t_adr), "correct memory chain");
224 // Otherwise the returned node represents memory for every slice
232 // Look for degenerate control and memory inputs. Bypass MergeMem inputs.
258 // Delay this memory node transformation until the control is processed.
263 // Ignore if memory is dead, or self-loop
269 // This memory slice may be dead.
270 // Delay this mem node transformation until the memory is processed.
323 // Avoid independent memory operations
329 // which memory slices they modify. So it is unsafe to move any memory
359 // control input of a memory operation predates (dominates)
482 // (b) Observe that the next memory state makes an exact match
529 continue; // (a) advance through independent store memory
539 continue; // (a) advance through independent store memory
570 mem = st_init->memory(alias_idx);
572 continue; // (a) advance through independent store memory
588 continue; // (a) advance through independent call memory
592 continue; // (a) advance through independent MemBar memory
596 continue; // (a) advance through independent allocation memory
605 continue; // (a) advance through independent MergeMem memory
610 // because 'mem' is an inscrutable memory state (e.g., a call).
621 if (t == Type::TOP) return NULL; // does not touch memory any more?
629 assert(cross_check == NULL || cross_check == TypePtr::BOTTOM, "expected memory type must be wide");
630 return TypePtr::BOTTOM; // touches lots of memory
647 "real address must not escape from expected memory type");
709 // going away in this pass and we need to make this memory op depend on the
731 // Scan upwards for the highest location we can place this memory op.
747 // Use its control edge for memory op because EncodeP may go away
769 // CastPP is going away in this pass! We need this memory op to be
810 // List of "safe" opcodes; those that implicitly block the memory
907 "raw memory operations should have control edge");
951 // will change the graph shape in a way which makes memory alive twice at the
968 // kind of node is encountered. Loads from final memory can skip
986 // Save the new memory state for the slice and fall through
1032 // (This can happen after LoadNode::Ideal resets the load's memory input
1415 // If the load is from Field memory and the pointer is non-null, we can
1460 // try to optimize our memory input
1472 // Delay this transformation until memory Phi is processed.
1488 // array memory alive twice: once for the hoisted Load and again after the
1768 // If we have an instance type and our memory input is the
1769 // programs's initial memory state, there is no matching store,
1773 assert(mem->as_Parm()->_con == TypeFunc::Memory, "must be memory Parm");
2238 ctl != NULL, "raw memory operations should have control edge");
2304 // Looking at a dead closed cycle of memory?
2309 "no mismatched stores, except on raw memory");
2415 // Do we Match on this edge index or not? Match only memory & value
2612 // Do we Match on this edge index or not? Do not match memory
2619 // Do we Match on this edge index or not? Do not match memory
2673 // Return allocation input memory edge if it is different instance
2781 // Do not match memory edge.
2906 // Construct projections for memory.
2919 // This node acts as a memory barrier on raw memory, after some raw stores.
2923 // It can avoid zeroing new storage for memory units which have raw inits.
2928 // ctl = incoming control; mem* = incoming memory
2929 // (Note: A star * on a memory edge denotes I/O and other standard edges.)
2930 // First allocate uninitialized memory and fill in the header:
2934 // Then initialize to zero the non-header parts of the raw memory block:
2947 // memory barrier (MemBarNode), it keeps critical stores from drifting
2957 // These stores must update raw memory, and they must be to addresses
2961 // Unlike most memory operations, they are not linked in a chain,
2972 // capturing of nearby memory operations.
2977 // initialized in fewer memory operations. Memory words which are
2989 // While an InitializeNode is incomplete, reads from the memory state
2993 // A write to the memory state, if it matches control and address,
2995 // InitializeNode. It is cloned as a raw memory operation and rewired
3030 Node* InitializeNode::memory(uint alias_idx) {
3035 // incoming raw memory is not split
3051 // raw-memory initializations. There is no need for
3052 // it to have anything to do with non-raw memory effects.
3054 // after skipping the memory effects of this initialization.
3119 // If we already know that the enclosing memory op is pinned right after
3147 // within the initialized memory.
3171 // and before the Store is using the memory location that the store
3177 // We are going to look at each use of the memory state following
3178 // the allocation to make sure nothing reads the memory that the
3204 // later) that is a direct use of the memory state
3220 // A load from the same memory slice as the store right
3317 // initialization interferes, then return zero_memory (the memory
3375 Node* prev_mem = NULL; // raw memory for the captured store
3396 // if it redundantly stored the same value (or zero to fresh memory).
3478 Node* zmem = zero_memory(); // initially zero memory state
3597 // Assuming big-endian memory, init0, init1 are 0x0000FF00, 0x000000FF.
3717 // Linearize the stores by ascending offset, to make memory
3733 Node* zmem = zero_memory(); // initially zero memory state
3899 // SEMANTICS OF MEMORY MERGES: A MergeMem is a memory state assembled from several
3900 // contributing store or call operations. Each contributor provides the memory
3902 // if a MergeMem has an input X for alias category #6, then any memory reference
3903 // to alias category #6 may use X as its memory state input, as an exact equivalent
3910 // The special alias category "Bot" (Compile::AliasIdxBot) includes all memory
3916 // overlap (i.e., one is Bot), the narrower alias type determines the memory
3921 // A merge can take a "wide" memory state as one of its narrow inputs.
3923 // the wide input. That is, wide memory states arriving at narrow merge inputs
3927 // and that memory slices "leak through":
3930 // But, in such a cascade, repeated memory slices can "block the leak":
3933 // In the last example, Y is not part of the combined memory state of the
3935 // memory states from arising, so you can be sure that the state Y is somehow
3949 // memory state has an edge in(AliasIdxBot) which is a "wide" memory state,
3955 // a memory state for the alias type <N>, or else the top node, meaning that
3958 // memory states at larger alias indexes. When merges grow, they are of course
3961 // This use of top is named "empty_memory()", or "empty_mem" (no-memory) as a variable.
3966 // first non-Bot memory slice, some low-level loops use it to initialize an
3972 // the memory state for alias type <N>, or (if there is no particular slice at <N>,
3973 // it returns the base memory. To prevent bugs, memory_at does not accept <Top>
3978 // really that different from the other memory inputs. An abbreviation called
3983 // partial memory states. When a Phi splits through a MergeMem, the copy of the Phi
3984 // that "emerges though" the base memory will be marked as excluding the alias types
3985 // of the other (narrow-memory) copies which "emerged through" the narrow edges:
3992 // actually a disjoint union of memory states, rather than an overlay.
4040 // Identity if this merge point does not record any interesting memory
4048 return this; // Many memory splits; no change
4052 return base_mem; // No memory splits; ID on the one true input
4070 return NULL; // Dead memory path.
4079 // simplify stacked MergeMems in base memory
4082 // the base memory might contribute new slices beyond my req()
4118 // calculate the old memory value
4123 // maybe update (reslice) the old memory value
4134 // A merge of BotPtr (default) with a RawPtr memory derived from a
4138 // In general, if loops degenerate and memory effects disappear,
4142 // Note: If a memory slice is a MergeMem cycle, it is unreachable
4149 // else preceding memory was not a MergeMem
4175 // A memory slice might have be be rewritten even if it is semantically
4190 // a self cycle indicates this memory path is dead
4218 // Check if PhiNode::Ideal's "Split phis through memory merges"
4240 assert(memory_at(req()) == new_base, "must set default memory");
4294 assert(n_adr_type != NULL, "new memory must have a well-defined adr_type");
4295 assert(C->must_alias(n_adr_type, alias_idx), "new memory must match selected slice");
4306 // memory can "leak through" calls on channels that
4336 "must be a wide memory");
4337 // AliasLevel == 0 if we are organizing the memory states manually.
4397 // look for the finite support of the other memory