Lines Matching defs:use
76 Node* use = n->fast_out(i);
77 if (use->is_Proj()) {
78 Block* buse = _bbs[use->_idx];
81 buse->find_remove(use); // Remove from wrong block
82 _bbs.map(use->_idx, b); // Re-insert in this block
83 b->add_inst(use);
90 // Nodes that have is_block_proj() nodes as their control need to use
224 // to root and nodes that use is_block_proj() nodes should be attached
312 // We are placing a definition, and have been given a def->use edge.
313 // The definition must dominate the use, so move the LCA upward in the
314 // dominator tree to dominate the use. If the use is a phi, adjust
315 // the LCA only with the phi input paths which actually use this def.
316 static Block* raise_LCA_above_use(Block* LCA, Node* use, Node* def, Block_Array &bbs) {
317 Block* buse = bbs[use->_idx];
318 if (buse == NULL) return LCA; // Unused killing Projs have no use block
319 if (!use->is_Phi()) return buse->dom_lca(LCA);
320 uint pmax = use->req(); // Number of Phi inputs
322 // the Phi? Well...it's like this. I do not have true def-use/use-def
323 // chains. Means I cannot distinguish, from the def-use direction, which
324 // of many use-defs lead from the same use to the same def. That is, this
325 // Phi might have several uses of the same def. Each use appears in a
327 // which use-def edge I should find the predecessor block for. So I find
331 if (use->in(j) == def) { // Found matching input?
519 // Recurse through MergeMem nodes to the stores that use them.
522 // that 'load' needs to use. We need to force 'load'
609 // Inserting an anti-dep between such a safepoint and a use
736 // did not interfere with any use of 'load'.
816 Node *use = n->is_Proj() ? n->in(0) : n;
817 uint use_rpo = _bbs[use->_idx]->_rpo;
823 if ( use_rpo == src_rpo && use->is_Phi() )
931 // Compute the latency of a specific use
932 int PhaseCFG::latency_from_use(Node *n, const Node *def, Node *use) {
934 if (use == n || use->is_Root())
940 // If the use is not a projection, then it is simple...
941 if (!use->is_Proj()) {
945 use->dump();
949 uint use_pre_order = _bbs[use->_idx]->_pre_order;
954 if (use_pre_order == def_pre_order && use->is_Phi())
957 uint nlen = use->len();
958 uint nl = _node_latency->at_grow(use->_idx);
961 if (use->in(j) == n) {
963 uint ul = use->latency(j);
975 // This is a projection, just grab the latency of the use(s)
976 for (DUIterator_Fast jmax, j = use->fast_outs(jmax); j < jmax; j++) {
977 uint l = latency_from_use(use, def, use->fast_out(j));
1176 Node* use = self->fast_out(i);
1177 LCA = raise_LCA_above_use(LCA, use, self, _bbs);
1181 // Place temps in the block of their use. This isn't a
1215 // Must clone guys stay next to use; no hoisting allowed.
1230 // Just use the LCA of the uses.