Lines Matching defs:Extract
1634 // Extract subvector is special because the value type
1995 // Extract subvector is special because the value type
3922 // Extract the relevant vectorWidth bits. Generate an EXTRACT_SUBVECTOR
4164 // Extract the LHS Lo/Hi vectors
4731 // Extract raw constant bits from constant pools.
4765 // Extract all the undef/constant element data and pack into single bitsets.
4847 // Extract scalar constant bits.
4860 // Extract constant bits from build vector.
4874 // Extract constant bits from constant pool vector.
4896 // Extract constant bits from a broadcasted constant pool scalar.
4921 // Extract constant bits from a subvector broadcast.
4953 // Extract a rematerialized scalar constant insertion.
4993 // Extract constant bits from a subvector's source.
5015 // Extract constant bits from shuffle node sources.
5094 // Extract the raw target constant bits.
5654 // Extract known constant input data.
5749 // Extract target shuffle mask sentinel elements to known undef/zero bitmasks.
8187 // Extract indexes do not match horizontal requirement.
11739 // EXTRQ: Extract Len elements from lower half of source, starting at Idx.
11794 // INSERTQ: Extract lowest Len elements from lower half of second source and
12827 if (SDValue Extract = lowerShuffleOfExtractsAsVperm(DL, V1, V2, Mask, DAG))
12828 return Extract;
12907 if (SDValue Extract = lowerShuffleOfExtractsAsVperm(DL, V1, V2, Mask, DAG))
12908 return Extract;
13125 if (SDValue Extract = lowerShuffleOfExtractsAsVperm(DL, V1, V2, Mask, DAG))
13126 return Extract;
13224 if (SDValue Extract = lowerShuffleOfExtractsAsVperm(DL, V1, V2, Mask, DAG))
13225 return Extract;
15403 // Extract + narrow shuffle is better than the wide alternative.
15516 // Extract the sub-lane mask, check that it all comes from the same lane
17385 SDValue Extract = DAG.getNode(ISD::EXTRACT_SUBVECTOR, DL, ExtractVT,
17390 Extract, DAG.getIntPtrConstant(0, DL));
17910 SDValue Extract = DAG.getNode(X86ISD::PEXTRB, dl, MVT::i32, Vec,
17912 return DAG.getNode(ISD::TRUNCATE, dl, VT, Extract);
17928 SDValue Extract = DAG.getNode(ISD::EXTRACT_VECTOR_ELT, dl, MVT::i32,
17930 return DAG.getBitcast(MVT::f32, Extract);
17939 /// Extract one bit from mask vector, like v16i1 or v8i1.
18102 SDValue Extract = DAG.getNode(X86ISD::PEXTRW, dl, MVT::i32, Vec,
18104 return DAG.getNode(ISD::TRUNCATE, dl, VT, Extract);
18118 // Extract either the lowest i32 or any i16, and extract the sub-byte.
19126 SDValue Extract = Cast.getOperand(0);
19128 if (Extract.getOpcode() != ISD::EXTRACT_VECTOR_ELT ||
19129 !isa<ConstantSDNode>(Extract.getOperand(1)))
19133 SDValue VecOp = Extract.getOperand(0);
19143 if (!isNullConstant(Extract.getOperand(1))) {
19145 Mask[0] = Extract.getConstantOperandVal(1);
19356 if (SDValue Extract = vectorizeExtractedCast(Op, dl, DAG, Subtarget))
19357 return Extract;
19863 if (SDValue Extract = vectorizeExtractedCast(Op, dl, DAG, Subtarget))
19864 return Extract;
20274 // Extract back to 128/256-bit if we widened.
21741 // Extract from a common vector.
23117 // Extract the LHS Lo/Hi vectors
23121 // Extract the RHS Lo/Hi vectors
24399 // Extract back to 128/256-bit if we widened.
25290 // Extract if the shift amount vector is larger than 128-bits.
28517 // Extract the lo/hi parts to any extend to i16.
28556 // Extract the odd parts.
28830 // Extract the LHS Lo/Hi vectors
28834 // Extract the RHS Lo/Hi vectors
32079 SDValue Extract =
32082 SDValue RetOps[] = {Extract, NewLoad.getValue(1)};
32176 SDValue Extract = DAG.getNode(ISD::EXTRACT_SUBVECTOR, dl, OrigVT,
32178 return DAG.getMergeValues({Extract, NewGather.getValue(1)}, dl);
32615 // Extract the high 32 bits from each result using PSHUFD.
36607 // Extract to 16 bits.
36675 // Extract to 16 bits.
39587 // Extract constant bits from each source op.
39754 // Extract target shuffle mask and resolve sentinels and inputs.
44279 static SDValue combineMinMaxReduction(SDNode *Extract, SelectionDAG &DAG,
44285 EVT ExtractVT = Extract->getValueType(0);
44292 Extract, BinOp, {ISD::SMAX, ISD::SMIN, ISD::UMAX, ISD::UMIN}, true);
44301 SDLoc DL(Extract);
44353 static SDValue combinePredicateReduction(SDNode *Extract, SelectionDAG &DAG,
44359 EVT ExtractVT = Extract->getValueType(0);
44367 SDValue Match = DAG.matchBinOpReduction(Extract, BinOp, {ISD::OR, ISD::AND});
44369 Match = DAG.matchBinOpReduction(Extract, BinOp, {ISD::XOR});
44379 SDLoc DL(Extract);
44492 static SDValue combineVPDPBUSDPattern(SDNode *Extract, SelectionDAG &DAG,
44497 EVT ExtractVT = Extract->getValueType(0);
44503 EVT VT = Extract->getOperand(0).getValueType();
44509 SDValue Root = DAG.matchBinOpReduction(Extract, BinOp, {ISD::ADD});
44531 SDLoc DL(Extract);
44560 Extract->getOperand(1));
44563 static SDValue combineBasicSADPattern(SDNode *Extract, SelectionDAG &DAG,
44569 EVT ExtractVT = Extract->getValueType(0);
44575 EVT VT = Extract->getOperand(0).getValueType();
44581 SDValue Root = DAG.matchBinOpReduction(Extract, BinOp, {ISD::ADD});
44607 SDLoc DL(Extract);
44634 Extract->getOperand(1));
51198 SDValue Extract = extractSubVector(
51200 Extract = DAG.getBitcast(RegVT, Extract);
51201 return DCI.CombineTo(N, Extract, SDValue(User, 1));
51289 SDValue Extract = extractSubVector(SDValue(User, 0), 0, DAG, dl,
51291 Extract = DAG.getBitcast(RegVT, Extract);
51292 return DCI.CombineTo(N, Extract, SDValue(User, 1));
51534 // Extract the one scalar element that is actually being stored.
51544 SDValue Extract =
51548 return DAG.getStore(MS->getChain(), DL, Extract, Addr,
51757 if (SDValue Extract = IsExtractedElement(StoredVal)) {
51758 SDValue Trunc = peekThroughOneUseBitcasts(Extract);
52748 // Extract constant bits and see if they are all
57614 SDValue Extract = extractSubVector(SDValue(User, 0), 0, DAG, SDLoc(N),
57616 Extract = DAG.getBitcast(VT, Extract);
57617 return DCI.CombineTo(N, Extract, SDValue(User, 1));
57699 // Extract down to real number of elements.
58532 // Extract CC code.