Lines Matching refs:And
1 //===- GVN.cpp - Eliminate redundant values and loads ---------------------===//
81 /// This class holds the mapping between values and value numbers. It is used
188 // Sort the operand value numbers so x<y and y>x get the same value number.
214 // Sort the operand value numbers so x<y and y>x get the same value number.
428 case Instruction::And:
636 /// our various maps and marks it for deletion.
663 /// value number, and remove the given instruction if encountered.
777 /// 3) we are speculating for this block and have used that to speculate for
785 // Optimistically assume that the block is fully available and check to see
809 // optimistic assumption and bail out.
816 // all, a fully-available block. We have a problem if we speculated on this and
828 // incorrect. Walk the (transitive) successors of this block and mark them as
869 /// If we saw a store of a value to memory, and
887 // If the store and reload are the same size, we can always reuse it.
925 // Convert vectors and fp to integer, which can be manipulated.
976 // If the load and store are to the exact same address, they should have been
991 // If the load and store don't overlap at all, the store doesn't provide
1241 // memset(P, 'x', 1234) -> splat('x'), even if x is a variable, and
1418 // If this is a clobber and L is the first instruction in its block, then
1471 // Reject loads and stores that are to the same address but are of
1489 // If the types mismatch and we can't handle it, reject reuse of the load.
1595 // all the preds that don't have an available LI and insert a new load into
1600 // Split critical edges, and update the unavailable predecessors accordingly.
1651 // and using PHI construction to get the value in the other predecessors, do
1762 // load, then it is fully redundant and we can use PHI insertion to compute
1763 // its value. Insert PHIs and remove the fully redundant value now.
1857 // FIXME: If both the original and replacement value are part of the
1860 // noalias scopes here and do better than the general conservative
1864 // regions, and so we need a conservative combination of the noalias
1881 /// locally, and then attempting non-local elimination if that fails.
1898 // If we have a clobber and target data is around, see if this is a clobber
1908 // a common base + constant offset, and if the previous store (or memset)
1925 // If this is a clobber and L is the first instruction in its block, then
1987 // The store and load are to a must-aliased pointer, but they may not
2071 // and then scan the list to find one whose block dominates the block in
2205 // the known equality was "(A != B)" == "false" then it follows that A and B
2219 // If "A && B" is known true then both A and B are known true. If "A || B"
2220 // is known false then both A and B are known false.
2245 // Floating point -0.0 and 0.0 compare equal, so we can only
2246 // propagate values if we know that we have a constant and that
2261 // out the value number that it would have and use that to find an
2303 // "%z = and i32 %x, %y" becomes "%z = and i32 %x, %x" which we now simplify.
2388 // Allocations are always uniquely numbered, so we can save time and memory
2412 // and the best replacement for itself. Nothing to do.
2487 // (and incrementing BI before processing an instruction).
2547 // find a value number, and should give up before we hurt ourselves.
2549 // and process newly inserted instructions.
2588 // sinking the compare again, and it would force the code generator to
2603 // a value is computed in the successor and one predecessor,
2646 // and we just need to insert a phi node. Otherwise, perform
2656 // the edge to be split and perform the PRE the next time we iterate
2710 /// control flow patterns and attempts to perform simple PRE at the join point.
2736 /// Split the critical edge connecting the given two blocks, and return
2767 // split critical edge, and hence may invalidate the RPO/DT iterator.
2884 // branch with constant condition), it will perform following analyses and
