Lines Matching defs:To
1 //===- ValueTracking.cpp - Walk computations to compute properties --------===//
64 // If all of the MaskV bits are known to be zero, then we know the
98 // fall back to the minimum known zeros in both operands.
109 // Are we still trying to solve for the sign bit?
141 // If the multiplication is known not to overflow, compute the sign bit.
180 // Only make use of no-wrap flags if we failed to compute the sign bit
182 // which case we prefer to follow the result of the direct computation,
197 // Use the high end of the ranges to find leading zeros.
212 /// Determine which bits of V are known to be either zero or one and return
215 /// NOTE: we cannot consider 'undef' to be "IsZero" here. The problem is that
217 /// it to be an explicit zero. If we don't change it to zero, other code could
258 // each element. There is no real need to handle ConstantVector here, because
281 // it the preferred alignment. Otherwise, we have to assume that it
351 // Output known-0 are known to be clear if zero in either the LHS | RHS.
361 // Output known-1 are known to be set if set in either the LHS | RHS.
371 // Output known-1 are known to be set if set in only one of the LHS, RHS.
384 // treat a udiv as a logical right shift by the power of 2 known to
441 // Any top bits are known to be zero.
450 // (bitcast i64 %x to <2 x i32>)
555 assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
584 // Since the result is less than or equal to either operand, any leading
608 // to determine if we can prove known low zero bits.
661 // this is sufficient to catch some interesting cases.
691 // We need to take the minimum number of known bits
708 // taking conservative care to avoid excessive recursion.
710 // Skip if every incoming value references to ourself.
722 // Recurse, but cap the recursion to one level, because we don't
723 // want to waste time spinning around in loops.
728 // If all bits have been ruled out, there's no need to check
740 // If a range metadata is attached to this IntrinsicInst, intersect the
796 assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
799 /// ComputeSignBit - Determine whether the sign bit is known to be zero or
816 /// isKnownToBeAPowerOfTwo - Return true if the given value is known to have exactly one
817 /// bit set when defined. For vectors return true if every element is known to
867 // Adding a power-of-two or zero to the same power-of-two or zero yields
909 /// \brief Test whether a GEP's result is known to be non-null.
911 /// Uses properties inherent in a GEP to try to determine whether it is known
912 /// to be non-null.
923 // If the base pointer is non-null, we cannot walk to a null address with an
962 // to recurse 10k times just because we have 10k GEP operands. We don't
963 // bail completely out because we want to handle constant GEPs regardless
975 /// isKnownNonZero - Return true if the given value is known to be non-zero
976 /// when defined. For vectors return true if every element is known to be
984 // Must be non-zero due to null test above.
1065 // to INT_MIN.
1070 // to INT_MIN.
1105 /// MaskedValueIsZero - Return true if 'V & Mask' is known to be zero. We use
1106 /// this predicate to simplify operations downstream. Mask is known to be zero
1125 /// is always equal to the sign bit (itself), but other cases can give us
1127 /// the top 3 bits are all equal to each other, so we return 3.
1134 "ComputeNumSignBits requires a DataLayout object to operate "
1186 // answer. Now proceed to the generic code that uses
1209 // If the input is known to be 0 or 1, the output is 0/-1, which is all
1233 // If the input is known to be 0 or 1, the output is 0/-1, which is all
1238 // If the input is known to be positive (the sign bit is known clear),
1269 // FIXME: it's tricky to do anything useful for this, but it is an important
1289 // Okay, we know that the sign bit in Mask is set. Use CLZ to determine
1294 // shifting. We don't want to return '64' as for an i32 "0".
1344 // otherwise fall through to ZExt
1419 /// value is never equal to -0.0.
1421 /// NOTE: this function will need to be revisited when we support non-default
1439 // (add x, 0.0) is guaranteed to return +0.0, not -0.0.
1535 // %a = zext i8 %X to i16
1548 // struct. To is the result struct built so far, new insertvalue instructions
1550 static Value *BuildSubAggregate(Value *From, Value* To, Type *IndexedType,
1556 // Save the original To argument so we can modify it
1557 Value *OrigTo = To;
1562 Value *PrevTo = To;
1563 To = BuildSubAggregate(From, To, STy->getElementType(i), Idxs, IdxSkip,
1566 if (!To) {
1578 if (To)
1579 return To;
1584 // we might be able to find the complete struct somewhere.
1593 return llvm::InsertValueInst::Create(To, V, makeArrayRef(Idxs).slice(IdxSkip),
1604 // struct, as opposed to just inserting a single struct. This will only work if
1611 assert(InsertBefore && "Must have someplace to insert!");
1614 Value *To = UndefValue::get(IndexedType);
1618 return BuildSubAggregate(From, To, IndexedType, Idxs, IdxSkip, InsertBefore);
1629 // Nothing to index? Just return V then (this is useful at the end of our
1664 // which allows the unused 0,0 element from the nested struct to be
1688 // However, we will need to chain I's indices with the requested indices.
1692 // Allocate some space to put the new indices in
1711 /// GetPointerBaseWithConstantOffset - Analyze the specified pointer to see if
1713 /// base and offset to the caller.
1750 /// null-terminated C string pointed to by V. If successful, it returns true
1766 // Make sure the index-ee is a pointer to array of i8.
1772 // Check to make sure that the first operand of the GEP is an integer and
1831 // These next two are very similar to the above, but also look through PHI
1835 /// GetStringLengthH - If we can compute the length of the string pointed to by
1884 /// GetStringLength - If we can compute the length of the string pointed to by
2018 // should be considered at least *safe* to speculate...
2035 // Sqrt should be OK, since the llvm sqrt intrinsic isn't defined to set
2042 // as libm. They're safe to speculate when they won't error.
2043 // TODO: are convert_{from,to}_fp16 safe?
