Lines Matching defs:IT
53 // This is expensive, so we only do it for the top level query value.
96 // figuring out if we can use it.
118 // it has been inserted).
149 IntegerType *IT = cast<IntegerType>(LHS->getType()->getScalarType());
150 APInt LHSKnownZero(IT->getBitWidth(), 0), LHSKnownOne(IT->getBitWidth(), 0);
151 APInt RHSKnownZero(IT->getBitWidth(), 0), RHSKnownOne(IT->getBitWidth(), 0);
402 // considered ephemeral to that assumption (even if it has other
459 // reach the assume whenever it reaches the context).
639 // Note: We currently implement two options. It's not clear which of these
649 // It does handle conditions far from the context instruction (e.g. early
1008 // It would be more-clearly correct to use the two temporaries for this
1013 // known bits. However this is expensive to compute, so be lazy about it and
1014 // only compute it when absolutely necessary.
1053 // stay disjoint (it should be better for some other code to actually
1306 // If it's known zero, our sign bit is also zero.
1566 // it the preferred alignment. Otherwise, we have to assume that it
1601 /// we cannot optimize based on the assumption that it is zero without changing
1602 /// it to be an explicit zero. If we don't change it to zero, other code could
1603 /// optimized based on the contradictory assumption that it is non-zero.
1610 /// same width as the vector element, and the bit is set only if it is true
1732 // it is shifted off the end then the result is undefined.
1737 // bottom. If it is shifted off the bottom then the result is undefined.
1814 /// Uses properties inherent in a GEP to try to determine whether it is known
1859 // We post-increment Depth here because while isKnownNonZero increments it
1875 /// ensure that the value it's attached to is never Value? 'RangeType' is
2091 /// Return true if it is known that V1 != V2.
2127 /// same width as the vector element, and the bit is set only if it is true
2337 // FIXME: it's tricky to do anything useful for this, but it is an important
2367 /// If successful, it returns true and returns the multiple in
2368 /// Multiple. If unsuccessful, it returns false. It looks
2496 // FIXME: Magic number! At the least, this should be given a name because it's
2498 // expose it as a parameter, so it can be used for testing / experimenting.
2547 // FIXME: Magic number! At the least, this should be given a name because it's
2549 // expose it as a parameter, so it can be used for testing / experimenting.
2600 /// return the i8 value that it is represented with. This is
2653 // but until there is an example that actually needs this, it doesn't seem
2659 // This is the recursive version of BuildSubAggregate. It takes a few different
2671 // Save the original To argument so we can modify it
2712 // This helper takes a nested struct and extracts a part of it (which is again a
2718 // It does this by inserting an insertvalue for each element in the resulting
2737 /// the scalar value indexed is already around as a register, for example if it
2826 /// Analyze the specified pointer to see if it can be expressed as a base
2861 /// by V. If successful, it returns true and returns the string in Str.
2862 /// If unsuccessful, it returns false.
2870 // If the value is a GEP instruction or constant expression, treat it as an
2935 // Trim off the \0 and anything after it. If the array is not nul
2953 // If this is a PHI node, there are two cases: either we have already seen it
2959 // If it was new, see if all the input strings are the same length.
3085 // loop, don't look through it. Consider:
3206 // Note that it is not safe to speculate into a malloc'd region because
3213 // It's not always safe to follow a bitcast, for example:
3357 // It's safe to hoist if the denominator is not 0 or -1.
3360 // At this point we know that the denominator is -1. It is safe to hoist as
3580 // We know it always overflows if multiplying the smallest possible values for
3605 // Create a simple add instruction, and insert it into the struct.
3611 // Create a simple add instruction, and insert it into the struct.
3731 // it only remains to consider left shift of poison by a positive
3758 // A ConstantInt cannot yield poison, so we can assume that it is
3808 // block, as that makes it easier to guarantee that the uses will be
3896 // An ordered comparison will return false when given a NaN, so it
3909 // An unordered comparison will return true when given a NaN, so it
