Lines Matching defs:Constant
416 /// constant build_vector of the stored constant values in Stores.
452 /// \brief Try to transform a truncation where C is a constant:
584 // Don't invert constant FP values after legalize. The negated constant
751 /// elements are all the same constant or undefined.
766 // \brief Returns the SDNode if it is a constant integer BuildVector
767 // or constant integer.
776 // \brief Returns the SDNode if it is a constant float BuildVector
777 // or constant float.
786 // \brief Returns the SDNode if it is a constant splat BuildVector or constant
807 // \brief Returns the SDNode if it is a constant splat BuildVector or constant
988 case ISD::Constant: {
1508 // Constant operands are canonicalized to RHS.
1665 // canonicalize constant to RHS
1720 // fold (A-B)+(C-D) to (A+C)-(B+D) when A or C is constant
1802 // canonicalize constant to RHS.
1837 // canonicalize constant to RHS
2049 // canonicalize constant to RHS (vector doesn't have to splat)
2310 // If the divisor is constant, then return DIVREM only if isIntDivCheap() is true.
2374 // If the divisor is constant, then return DIVREM only if isIntDivCheap() is true.
2437 // If X/C can be simplified by the division-by-constant logic, lower
2700 // canonicalize constant to RHS
3047 // canonicalize constant to RHS
3099 // Get the constant (if applicable) the zero'th operand is being ANDed with.
3100 // This can be a pure constant or a vector splat, in which case we treat the
3102 APInt Constant = APInt::getNullValue(1);
3104 Constant = C->getAPIntValue();
3119 // lanes of the constant together.
3132 // Make sure that variable 'Constant' is only set if 'SplatBitSize' is a
3135 Constant = APInt::getAllOnesValue(BitWidth);
3137 Constant &= SplatValue.lshr(i*BitWidth).zextOrTrunc(BitWidth);
3149 // Resize the constant to the same size as the original memory access before
3152 Constant =
3153 Constant.zextOrTrunc(Load->getMemoryVT().getScalarType().getSizeInBits());
3163 if (B && Constant.isAllOnesValue()) {
3763 // canonicalize constant to RHS
4109 // canonicalize constant to RHS
4243 /// constant.
4270 // We require the RHS of the binop to be a constant and not opaque as well.
4274 // FIXME: disable this unless the input to the binop is a shift by a constant.
4290 // boolean indicates the value of the high bit of the constant which would
5669 // Determine if the condition we're dealing with is constant
5766 // Get the constant value and if needed trunc it to the size of the type.
6083 N0.getOperand(1).getOpcode() == ISD::Constant &&
6316 N0.getOperand(1).getOpcode() == ISD::Constant &&
6375 N0.getOperand(1).getOpcode() == ISD::Constant &&
6567 N0.getOperand(1).getOpcode() == ISD::Constant &&
6681 case ISD::Constant: {
6833 // It's not possible to generate a constant of extended or untyped type.
7258 // If the input is a BUILD_VECTOR with all constant elements, fold this now.
7261 // First check to see if this is all constant.
7274 // If the input is a constant, let getNode fold it.
7283 TLI.isOperationLegal(ISD::Constant, VT)))
7328 // This often reduces constant pool loads.
7464 // If operands are a constant, just bitcast back to original VT.
7506 /// We know that BV is a build_vector node with Constant, ConstantFP or Undef
8178 // canonicalize constant to RHS
8196 // No FP constant should be created after legalization as Instruction
8394 // canonicalize constant to RHS
8420 // a constant. Otherwise, we may induce infinite looping.
8486 // Constant fold FMA.
8817 if (N0CFP && N1CFP) // Constant fold
9177 // Constant fold FNEG.
9186 // constant pool values.
9244 // Canonicalize to constant on RHS.
9265 // Canonicalize to constant on RHS.
9291 // constant pool values.
9324 // If N is a constant we could fold this into a fallthrough or unconditional
9365 // This applies only when the AND constant value has one bit set and the
9366 // SRL constant is equal to the log2 of the AND constant. The back-end is
9372 Op1.getOpcode() == ISD::Constant) {
9375 if (AndOp1.getOpcode() == ISD::Constant) {
9470 // If N is a constant we could fold this into a fallthrough or unconditional
9584 // constant base with a variable offset so that constant coercion
9616 // If the offset is a constant, there may be other adds of constants that
9893 // regular Constants (if the constant is not opaque).
9946 // target constant into a regular constant).
10637 // Check the constant mask. Invert it so that the bits being masked out are
10774 Value.getOperand(1).getOpcode() != ISD::Constant)
11029 // Walk all the users of the constant with which we're multiplying.
11039 // OtherOp is what we're multiplying against the constant.
11161 // Construct a single integer constant which is made of the smaller
11162 // constant inputs.
11176 llvm_unreachable("Invalid constant element type");
11449 // Non-constant.
11453 // Find a legal type for the constant store.
11474 // We only use vectors if the constant is known to be zero or the target
12563 // constant index, bail out.
12600 (Opcode == ISD::Constant || Opcode == ISD::ConstantFP) &&
12980 // The extract index must be constant.
13609 N0->getNumOperands() == 2 && N2.getOpcode() == ISD::Constant) {
13706 // Extract the sub element from the constant bit mask.
13758 // See if we can constant fold the vector operation.
13763 // Try to convert a constant mask AND into a shuffle clear mask.
13872 // constants have been dropped into the constant pool.
13986 // Determine if the condition we're dealing with is constant
14016 // where "tmp" is a constant pool entry containing an array with 1.0 and 2.0
14017 // in it. This is a win when the constant is not otherwise available because
14018 // it replaces two constant pool loads with one. We only do this if the FP
14022 // it is legal, we may not need to store the FP constant in a constant pool.
14033 Constant *Elts[] = {
14041 Constant *CA = ConstantArray::get(ArrayType::get(FPTy, 2), Elts);
14079 // single-bit constant.
14231 /// Given an ISD::SDIV node expressing a divide by constant, return
14253 /// Given an ISD::SDIV node expressing a divide by constant power of 2, return a
14272 /// Given an ISD::UDIV node expressing a divide by constant, return a DAG
14351 // this entire sequence requires only one FP constant.
14436 // If it's an adding a simple constant then integrate the offset.
14453 // Return the underlying Constant value, and update the Offset. Return false
14454 // for ConstantSDNodes since the same constant pool entry may be represented
