Lines Matching defs:Extract
1674 // Extract subvector is special because the value type
2043 // Extract subvector is special because the value type
4075 // Extract the relevant vectorWidth bits. Generate an EXTRACT_SUBVECTOR
4328 // Extract the LHS Lo/Hi vectors
4895 // Extract raw constant bits from constant pools.
4929 // Extract all the undef/constant element data and pack into single bitsets.
5011 // Extract scalar constant bits.
5024 // Extract constant bits from build vector.
5038 // Extract constant bits from constant pool vector.
5060 // Extract constant bits from a broadcasted constant pool scalar.
5085 // Extract constant bits from a subvector broadcast.
5117 // Extract a rematerialized scalar constant insertion.
5157 // Extract constant bits from a subvector's source.
5179 // Extract constant bits from shuffle node sources.
5258 // Extract the raw target constant bits.
5853 // Extract known constant input data.
5948 // Extract target shuffle mask sentinel elements to known undef/zero bitmasks.
8411 // Extract indexes do not match horizontal requirement.
12002 // EXTRQ: Extract Len elements from lower half of source, starting at Idx.
12057 // INSERTQ: Extract lowest Len elements from lower half of second source and
13104 if (SDValue Extract = lowerShuffleOfExtractsAsVperm(DL, V1, V2, Mask, DAG))
13105 return Extract;
13184 if (SDValue Extract = lowerShuffleOfExtractsAsVperm(DL, V1, V2, Mask, DAG))
13185 return Extract;
13402 if (SDValue Extract = lowerShuffleOfExtractsAsVperm(DL, V1, V2, Mask, DAG))
13403 return Extract;
13501 if (SDValue Extract = lowerShuffleOfExtractsAsVperm(DL, V1, V2, Mask, DAG))
13502 return Extract;
15701 // Extract + narrow shuffle is better than the wide alternative.
15814 // Extract the sub-lane mask, check that it all comes from the same lane
17691 SDValue Extract =
17695 DAG.getConstant(0, DL, VT), Extract,
18279 SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32, Vec,
18281 return DAG.getNode(ISD::TRUNCATE, dl, VT, Extract);
18297 SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
18299 return DAG.getBitcast(MVT::f32, Extract);
18308 /// Extract one bit from mask vector, like v16i1 or v8i1.
18471 SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32, Vec,
18473 return DAG.getNode(ISD::TRUNCATE, dl, VT, Extract);
18487 // Extract either the lowest i32 or any i16, and extract the sub-byte.
19506 SDValue Extract = Cast.getOperand(0);
19508 if (Extract.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
19509 !isa<ConstantSDNode>(Extract.getOperand(1)))
19513 SDValue VecOp = Extract.getOperand(0);
19523 if (!isNullConstant(Extract.getOperand(1))) {
19525 Mask[0] = Extract.getConstantOperandVal(1);
19736 if (SDValue Extract = vectorizeExtractedCast(Op, dl, DAG, Subtarget))
19737 return Extract;
20243 if (SDValue Extract = vectorizeExtractedCast(Op, dl, DAG, Subtarget))
20244 return Extract;
20654 // Extract back to 128/256-bit if we widened.
22123 // Extract from a common vector.
23497 // Extract the LHS Lo/Hi vectors
23501 // Extract the RHS Lo/Hi vectors
24896 // Extract back to 128/256-bit if we widened.
25780 // Extract if the shift amount vector is larger than 128-bits.
29195 // Extract the lo/hi parts to any extend to i16.
29234 // Extract the odd parts.
29508 // Extract the LHS Lo/Hi vectors
29512 // Extract the RHS Lo/Hi vectors
32909 SDValue Extract =
32912 SDValue RetOps[] = {Extract, NewLoad.getValue(1)};
33006 SDValue Extract = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OrigVT, NewGather,
33008 return DAG.getMergeValues({Extract, NewGather.getValue(1)}, dl);
33468 // Extract the high 32 bits from each result using PSHUFD.
37430 // Extract to 16 bits.
37498 // Extract to 16 bits.
40632 // Extract constant bits from each source op.
40799 // Extract target shuffle mask and resolve sentinels and inputs.
45465 static SDValue combineMinMaxReduction(SDNode *Extract, SelectionDAG &DAG,
45471 EVT ExtractVT = Extract->getValueType(0);
45478 Extract, BinOp, {ISD::SMAX, ISD::SMIN, ISD::UMAX, ISD::UMIN}, true);
45487 SDLoc DL(Extract);
45539 static SDValue combinePredicateReduction(SDNode *Extract, SelectionDAG &DAG,
45545 EVT ExtractVT = Extract->getValueType(0);
45553 SDValue Match = DAG.matchBinOpReduction(Extract, BinOp, {ISD::OR, ISD::AND});
45555 Match = DAG.matchBinOpReduction(Extract, BinOp, {ISD::XOR});
45565 SDLoc DL(Extract);
45678 static SDValue combineVPDPBUSDPattern(SDNode *Extract, SelectionDAG &DAG,
45683 EVT ExtractVT = Extract->getValueType(0);
45689 EVT VT = Extract->getOperand(0).getValueType();
45695 SDValue Root = DAG.matchBinOpReduction(Extract, BinOp, {ISD::ADD});
45717 SDLoc DL(Extract);
45746 Extract->getOperand(1));
45749 static SDValue combineBasicSADPattern(SDNode *Extract, SelectionDAG &DAG,
45755 EVT ExtractVT = Extract->getValueType(0);
45761 EVT VT = Extract->getOperand(0).getValueType();
45767 SDValue Root = DAG.matchBinOpReduction(Extract, BinOp, {ISD::ADD});
45793 SDLoc DL(Extract);
45820 Extract->getOperand(1));
52390 SDValue Extract = extractSubVector(
52392 Extract = DAG.getBitcast(RegVT, Extract);
52393 return DCI.CombineTo(N, Extract, SDValue(User, 1));
52481 SDValue Extract = extractSubVector(SDValue(User, 0), 0, DAG, dl,
52483 Extract = DAG.getBitcast(RegVT, Extract);
52484 return DCI.CombineTo(N, Extract, SDValue(User, 1));
52726 // Extract the one scalar element that is actually being stored.
52736 SDValue Extract =
52740 return DAG.getStore(MS->getChain(), DL, Extract, Addr,
52972 if (SDValue Extract = IsExtractedElement(StoredVal)) {
52973 SDValue Trunc = peekThroughOneUseBitcasts(Extract);
53996 // Extract constant bits and see if they are all
59124 SDValue Extract = extractSubVector(SDValue(User, 0), 0, DAG, SDLoc(N),
59126 Extract = DAG.getBitcast(VT, Extract);
59127 return DCI.CombineTo(N, Extract, SDValue(User, 1));
59209 // Extract down to real number of elements.
60146 // Extract CC code.