Lines Matching refs:Result
63 static SDValue Insert128BitVector(SDValue Result,
115 SDValue Result = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, ResultVT, Vec,
118 return Result;
129 static SDValue Insert128BitVector(SDValue Result,
142 EVT ResultVT = Result.getValueType();
154 Result = DAG.getNode(ISD::INSERT_SUBVECTOR, dl, ResultVT, Result, Vec,
156 return Result;
178 // This is half the length of the result
381 // the two-result form to trivial CSE, which is able to combine x/y and x%y
384 // Scalar integer multiply-high is also lowered to use two-result
386 // (low) operations are left as Legal, as there are single-result
387 // instructions for this in x86. Using the two-result multiply instructions
1015 // (result) is 128-bit but the source is 256-bit wide.
1178 /// and store operations as a result of memset, memcpy, and memmove
1367 // Copy the result values into the output registers.
1487 /// LowerCallResult - Lower the result values of a call into the
1504 // Copy all of the result registers out of their specified physreg.
1842 // may be loaded by deferencing the result of va_next.
2407 // Handle result values, copying them out of physregs into vregs that we
2588 // If the call result is in ST0 / ST1, it needs to be popped off the x87 stack.
3541 bool Result = (Index * ElSize) % 128 == 0;
3543 return Result;
3560 bool Result = (Index * ElSize) % 128 == 0;
3562 return Result;
3964 /// element of the result of the vector shuffle.
4712 SDValue Result;
4714 Result = DAG.getNode(ISD::SCALAR_TO_VECTOR, dl, VT, Op.getOperand(0));
4716 Result = DAG.getUNDEF(VT);
4720 Result = DAG.getNode(ISD::INSERT_VECTOR_ELT, dl, VT, Result,
4723 return Result;
4803 // of the result come from the same quadword of one of the two inputs. Undef
4841 // For SSSE3, If all 8 words of the result come from only 1 quadword of each
4917 // If we have SSSE3, and all words of the result are from 1 input vector,
5065 // If we have SSSE3, case 1 is generated when all result bytes come from
5081 // If SSSE3, use 1 pshufb instruction per vector with elements in the result.
5085 // If all result elements are from one input vector, then only translate
5086 // undef mask values to 0x80 (zero out result) in the pshufb mask.
5137 // This word of the result is all undef, skip it.
5141 // This word of the result is already in the correct place, skip it.
5178 // inserting them in the result.
6027 // the result back to FR32 register. It's only worth matching if the
6028 // result has a single use which is a store or a bitcast to i32. And in
6063 // If this is a 256-bit vector result, first extract the 128-bit
6110 // Transform it so it match pextrw which produces a 32-bit result.
6138 // Note if the lower 64 bits of the result of the UNPCKHPD is then stored
6209 // If this is a 256-bit vector result, first insert into a 128-bit
6261 // If this is a 256-bit vector result, first insert into a 128-bit
6288 // Lower a node with an EXTRACT_SUBVECTOR opcode. This may result in
6306 // Lower a node with an INSERT_SUBVECTOR opcode. This may result in a
6349 SDValue Result = DAG.getTargetConstantPool(CP->getConstVal(), getPointerTy(),
6353 Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
6356 Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
6359 Result);
6362 return Result;
6382 SDValue Result = DAG.getTargetJumpTable(JT->getIndex(), getPointerTy(),
6385 Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
6389 Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
6392 Result);
6394 return Result;
6415 SDValue Result = DAG.getTargetExternalSymbol(Sym, getPointerTy(), OpFlag);
6418 Result = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
6424 Result = DAG.getNode(ISD::ADD, DL, getPointerTy(),
6427 Result);
6430 return Result;
6441 SDValue Result = DAG.getBlockAddress(BA, getPointerTy(),
6446 Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
6448 Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
6452 Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
6454 Result);
6457 return Result;
6469 SDValue Result;
6473 Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), Offset);
6476 Result = DAG.getTargetGlobalAddress(GV, dl, getPointerTy(), 0, OpFlags);
6481 Result = DAG.getNode(X86ISD::WrapperRIP, dl, getPointerTy(), Result);
6483 Result = DAG.getNode(X86ISD::Wrapper, dl, getPointerTy(), Result);
6487 Result = DAG.getNode(ISD::ADD, dl, getPointerTy(),
6489 Result);
6495 Result = DAG.getLoad(getPointerTy(), dl, DAG.getEntryNode(), Result,
6501 Result = DAG.getNode(ISD::ADD, dl, getPointerTy(), Result,
6504 return Result;
6653 SDValue Result = DAG.getTargetGlobalAddress(GA->getGlobal(), DL,
6656 SDValue Offset = DAG.getNode(WrapperKind, DL, getPointerTy(), Result);
6794 SDValue Result = DAG.getMemIntrinsicNode(useSSE ? X86ISD::FILD_FLAG :
6800 Chain = Result.getValue(1);
6801 SDValue InFlag = Result.getValue(2);
6812 Chain, Result, StackSlot, DAG.getValueType(Op.getValueType()), InFlag
6822 Result = DAG.getLoad(Op.getValueType(), DL, Chain, StackSlot,
6827 return Result;
6856 // All conversions up to here are exact. The correctly rounded result is
6919 // FP constant to bias correct the final result.
7131 // Load the result.
7142 // Load the result.
7229 // At this point the operands and the result should have the same
7333 // leads to the ADD being left around and reselected, with the result being
7366 // If the primary and result isn't used, don't bother using X86ISD::AND,
7452 /// LowerToBT - Result of 'and' is compared against zero. Turn it into a BT node
7670 SDValue Result = DAG.getNode(Opc, dl, VT, Op0, Op1);
7672 // If the logical-not of the result is required, perform that now.
7674 Result = DAG.getNOT(dl, Result, VT);
7676 return Result;
7796 // We know the result of AND is compared against zero. Try to match
7830 // X86ISD::CMOV means set the result (which is operand 1) to the RHS if
7988 // We know the result of AND is compared against zero. Try to match
8297 // or testp pattern and a setcc for the result.
9200 SDValue Result = DAG.getMemIntrinsicNode(X86ISD::LCMPXCHG_DAG, DL, Tys,
9203 DAG.getCopyFromReg(Result.getValue(0), DL, Reg, T, Result.getValue(1));
9209 assert(Subtarget->is64Bit() && "Result not type legalized?");
9373 SDValue Result =
9376 SDValue OpsF[] = { Result.getValue(0), Result.getValue(1)};
9378 Results.push_back(Result.getValue(2));
9381 /// ReplaceNodeResults - Replace a node with an illegal result type
9449 SDValue Result = DAG.getMemIntrinsicNode(X86ISD::LCMPXCHG8_DAG, dl, Tys,
9451 SDValue cpOutL = DAG.getCopyFromReg(Result.getValue(0), dl, X86::EAX,
9452 MVT::i32, Result.getValue(1));
9881 // result in out1, out2
10602 // %Result = phi [ %FalseValue, copy0MBB ], [ %TrueValue, thisMBB ]
11069 // These nodes' second result is a boolean.
11421 case 1: // result = add base, cond
11422 case 2: // result = lea base( , cond*2)
11423 case 3: // result = lea base(cond, cond*2)
11424 case 4: // result = lea base( , cond*4)
11425 case 5: // result = lea base(cond, cond*4)
11426 case 8: // result = lea base( , cond*8)
11427 case 9: // result = lea base(cond, cond*8)
11541 case 1: // result = add base, cond
11542 case 2: // result = lea base( , cond*2)
11543 case 3: // result = lea base(cond, cond*2)
11544 case 4: // result = lea base( , cond*4)
11545 case 5: // result = lea base(cond, cond*4)
11546 case 8: // result = lea base( , cond*8)
11547 case 9: // result = lea base(cond, cond*8)
11650 // since the result of setcc_c is all zero's or all ones.
12304 // the result is either zero or one (depending on the input carry bit).
12818 SDValue Result(0, 0);
12829 Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
12837 Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
12845 Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
12853 Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
12864 Result = DAG.getTargetConstant(C->getSExtValue(), MVT::i64);
12877 Result = DAG.getTargetConstant(C->getZExtValue(), Op.getValueType());
12889 Result = DAG.getTargetConstant(CST->getSExtValue(), MVT::i64);
12934 Result = DAG.getTargetGlobalAddress(GV, Op.getDebugLoc(),
12940 if (Result.getNode()) {
12941 Ops.push_back(Result);
