| /src/external/apache2/llvm/dist/llvm/lib/Target/AArch64/GISel/ |
| AArch64GlobalISelUtils.cpp | 23 if (auto Splat = getVectorSplat(MI, MRI))
24 return Splat;
37 auto Splat = getAArch64VectorSplat(MI, MRI);
38 if (!Splat || Splat->isReg())
40 return Splat->getCst();
|
| AArch64PostLegalizerLowering.cpp | 307 // Try to match a vector splat operation into a dup instruction.
315 // %splat:fpr(<2 x s64>) = G_SHUFFLE_VECTOR %ins(<2 x s64>), %undef, %zerovec(<2 x s32>)
318 // %splat = G_DUP %scalar
363 // If this is undef splat, generate it via "just" vdup, if possible.
723 auto Splat = getAArch64VectorSplat(MI, MRI);
724 if (!Splat)
726 if (Splat->isReg())
731 int64_t Cst = Splat->getCst();
926 auto Splat = getAArch64VectorSplat(*MRI.getVRegDef(RHS), MRI);
929 bool IsZero = Splat && Splat->isCst() && Splat->getCst() == 0
[all...] |
| /src/crypto/external/apache2/openssl/lib/libcrypto/arch/riscv64/ |
| aes-riscv64-zvkb-zvkned.S | 67 # Splat the IV to v16
166 # Splat the IV to v16
271 # Splat the IV to v16
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/ARM/MCTargetDesc/ |
| ARMAddressingModes.h | 321 // If 'Arg' is an 8-bit splat, then get the encoded value.
322 int Splat = getT2SOImmValSplatVal(Arg);
323 if (Splat != -1)
324 return Splat;
343 // Passing values can be any combination of splat values and shifter
344 // values. If this can be handled with a single shifter or splat, bail
355 // Likewise, try masking out a splat value first.
376 // Try masking out a splat value first.
380 // The other splat is all that's left as an option.
613 // Encode NEON 16 bits Splat immediate for instructions like VBIC/VOR
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Analysis/ |
| TargetTransformInfo.cpp | 676 const Value *Splat = getSplatValue(V);
678 // Check for a splat of a constant or for a non uniform vector of constants
682 if (Splat) {
684 if (auto *CI = dyn_cast<ConstantInt>(Splat))
699 // Check for a splat of a uniform value. This is not loop aware, so return
701 if (Splat && (isa<Argument>(Splat) || isa<GlobalValue>(Splat)))
|
| VectorUtils.cpp | 335 // There can be only 1 non-negative mask element value if this is a splat.
339 // Initialize the splat index to the 1st non-negative mask element.
346 /// Get splat value if the input is a splat vector or return nullptr.
348 /// the input value is (1) a splat constant vector or (2) a sequence
355 // shuf (inselt ?, Splat, 0), ?, <0, undef, 0, ...>
356 Value *Splat;
358 m_Shuffle(m_InsertElt(m_Value(), m_Value(Splat), m_ZeroInt()),
360 return Splat;
396 // If both operands of a binop are splats, the result is a splat
[all...] |
| InstructionSimplify.cpp | 4480 // The index is not relevant if our vector is a splat.
4481 if (auto *Splat = CVec->getSplatValue())
4482 return Splat;
4692 // A splat of an inserted scalar constant becomes a vector constant:
4702 // Match a splat shuffle mask of the insert index allowing undef elements.
4707 assert(isa<UndefValue>(Op1) && "Expected undef operand 1 for splat");
4718 // A shuffle of a splat is always the splat itself. Legal if the shuffle's
5449 // TODO: loosen undef/splat restrictions for vector constants.
|
| /src/external/apache2/llvm/dist/llvm/lib/CodeGen/GlobalISel/ |
| Utils.cpp | 696 // TODO: Constant splat
850 "Only G_SHUFFLE_VECTOR can have a splat index!");
854 // If all elements are undefined, this shuffle can be considered a splat.
928 if (auto Splat = getBuildVectorConstantSplat(MI, MRI))
929 return RegOrConstant(*Splat);
|
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Scalar/ |
| LowerMatrixIntrinsics.cpp | 1061 Value *Splat = Builder.CreateVectorSplat(BlockSize, RH, "splat");
1062 Sum = createMulAdd(isSumZero && K == 0 ? nullptr : Sum, L, Splat,
1088 Value *Splat = Builder.CreateVectorSplat(BlockSize, LH, "splat");
1089 Sum = createMulAdd(isSumZero && K == 0 ? nullptr : Sum, Splat, R,
|
| SROA.cpp | 2748 /// \param V The i8 value to splat.
2768 /// Compute a vector splat for a given element value.
2771 LLVM_DEBUG(dbgs() << " splat: " << *V << "\n");
2848 Value *Splat = getIntegerSplat(
2850 Splat = convertValue(DL, IRB, Splat, ElementTy);
2852 Splat = getVectorSplat(Splat, NumElements);
2856 V = insertVector(IRB, Old, Splat, BeginIndex, "vec");
|
| RewriteStatepointsForGC.cpp | 2865 auto *Splat = B.CreateVectorSplat(VF, I.getOperand(0));
2866 I.setOperand(0, Splat);
|
| /src/external/apache2/llvm/dist/llvm/include/llvm/Analysis/ |
| TargetTransformInfoImpl.h | 882 // cost of Vector GEP with splat constant index are the same.
885 if (auto Splat = getSplatValue(*I))
886 ConstIdx = dyn_cast<ConstantInt>(Splat);
888 // For structures the index is always splat or scalar constant
|
| /src/external/apache2/llvm/dist/llvm/lib/IR/ |
| ConstantFold.cpp | 64 if (Constant *Splat = CV->getSplatValue()) {
66 ConstantExpr::getBitCast(Splat, DstEltTy));
606 if (Constant *Splat = V->getSplatValue()) {
609 ConstantExpr::getCast(opc, Splat, DstEltTy));
973 // If the mask is all zeros this is a splat, no need to go through all
1091 if (Constant *Splat = C->getSplatValue()) {
1092 Constant *Elt = ConstantExpr::get(Opcode, Splat);
|
| Constants.cpp | 112 if (Constant *Splat = CV->getSplatValue())
113 return Splat->isAllOnesValue();
138 if (Constant *Splat = CV->getSplatValue())
139 return Splat->isOneValue();
188 if (Constant *Splat = CV->getSplatValue())
189 return Splat->isMinSignedValue();
1413 // If this splat is compatible with ConstantDataVector, use it instead of
1435 // Build shuffle mask to perform the splat.
1437 // Splat.
1708 // Check if this is a constant expression splat of the form returned b
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/RISCV/ |
| RISCVISelLowering.cpp | 1333 SDValue Splat = DAG.getNode(Opc, DL, ContainerVT, Op.getOperand(0), VL);
1334 return convertFromScalableVector(VT, Splat, DAG, Subtarget);
1440 if (SDValue Splat = cast<BuildVectorSDNode>(Op)->getSplatValue()) {
1441 // For a splat, perform a scalar truncate before creating the wider
1443 assert(Splat.getValueType() == XLenVT &&
1444 "Unexpected type for i1 splat value");
1445 Splat = DAG.getNode(ISD::AND, DL, XLenVT, Splat,
1447 WideVec = DAG.getSplatBuildVector(WideVecVT, DL, Splat);
1458 if (SDValue Splat = cast<BuildVectorSDNode>(Op)->getSplatValue())
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/InstCombine/ |
| InstCombineVectorOps.cpp | 1103 // TODO: If the base vector is not undef, it might be better to create a splat
1116 // Splat from element 0, but replace absent elements with undef in the mask.
1125 /// Try to fold an insert element into an existing splat shuffle by changing
1128 // Check if the vector operand of this insert is a canonical splat shuffle.
1143 // Check if the splat shuffle's input is the same as this insert's scalar op.
1455 if (Instruction *Splat = foldInsEltIntoSplat(IE))
1456 return Splat;
1807 // a vector, this is a splat of something like 0, -1, or 1.
1846 /// canonical form of splat.
1854 // Match a shuffle that is a splat to a non-zero element
[all...] |
| InstCombineCalls.cpp | 354 // * Vector splat address w/known mask -> scalar load
364 // * Vector splat address w/known mask -> scalar store
508 // TODO: Handle splat vectors.
1555 if (ConstantInt *Splat =
1557 if (Splat->isOne())
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/WebAssembly/ |
| WebAssemblyISelLowering.cpp | 1886 // Use a splat, but possibly a load_splat
2199 // (concat_vectors (v2i32 (fp_to_{s,u}int_sat $x, 32)), (v2i32 (splat 0)))
2217 auto *Splat = dyn_cast<BuildVectorSDNode>(N->getOperand(1));
2221 if (!Splat || !Splat->isConstantSplat(SplatValue, SplatUndef, SplatBitSize,
|
| /src/external/apache2/llvm/dist/llvm/lib/CodeGen/SelectionDAG/ |
| SelectionDAG.cpp | 1430 // splat.
1803 // If shuffling a splat, try to blend the splat instead. We do this here so
1807 SDValue Splat = BV->getSplatValue(&UndefElements);
1808 if (!Splat)
1869 // Shuffling a constant splat doesn't change the result.
1878 // A splat should always show up as a build vector node.
1881 SDValue Splat = BV->getSplatValue(&UndefElements);
1882 // If this is a splat of an undef, shuffling it is also undef.
1883 if (Splat && Splat.isUndef()
[all...] |
| DAGCombiner.cpp | 962 // Determines if it is a constant integer or a splat/build vector of constant
3736 // Canonicalize constant to RHS (vector doesn't have to splat)
3769 "Splat APInt should be element width");
3782 // canonicalize constant to RHS (vector doesn't have to splat)
4213 // Splat the sign bit into the register
5621 if (ConstantSDNode *Splat = BVec->getConstantSplatNode()) {
5624 if (Splat->getAPIntValue().isMask(ElementSize)) {
5713 // This can be a pure constant or a vector splat, in which case we treat the
5714 // vector as a scalar and use the splat value.
5729 // The splat value may be something like "0x00FFFFFF", which means 0 fo
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Vectorize/ |
| SLPVectorizer.cpp | 911 Splat, ///< Matching the same instruction multiple times (broadcast)
966 /// Identical instructions (a.k.a. splat or broadcast).
1116 // or if they are SPLAT,
1240 case ReorderingMode::Splat:
1424 ReorderingModes[OpIdx] = ReorderingMode::Splat;
1431 // Our best hope is a Splat. It may save some cost in some cases.
1432 ReorderingModes[OpIdx] = ReorderingMode::Splat;
1496 case ReorderingMode::Splat:
1497 return "Splat";
2528 OS << "<splat> " << *Entry->Scalars[0]
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/SystemZ/ |
| SystemZISelLowering.cpp | 797 // Find the smallest splat.
818 // Get IntBits by finding the 128 bit splat.
822 // Get SplatBits by finding the 8 bit or greater splat.
4404 if (SystemZISD::SPLAT == ShuffleOp.getOpcode() &&
5179 "Splat index should be defined and in first operand");
5185 return DAG.getNode(SystemZISD::SPLAT, DL, VT, Op.getOperand(0),
5320 // See whether the shift vector is a splat represented as BUILD_VECTOR.
5336 SDValue Splat = BVN->getSplatValue(&UndefElements);
5337 if (Splat) {
5340 SDValue Shift = DAG.getNode(ISD::TRUNCATE, DL, MVT::i32, Splat);
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/AArch64/ |
| AArch64ISelLowering.cpp | 4160 SDValue Splat = Index.getOperand(1);
4161 if (Splat.getOpcode() != ISD::SPLAT_VECTOR)
4163 ConstantSDNode *Mask = dyn_cast<ConstantSDNode>(Splat.getOperand(0));
4176 // getelementptr nullptr, <vscale x N x T> (splat(%offset)) + %indices)
4179 // getelementptr nullptr, <vscale x N x T> (splat(#x)) + %indices)
9024 // If this is undef splat, generate it via "just" vdup, if possible.
9181 // Extend input splat value where needed to fit into a GPR (32b or 64b only)
9665 // operands already. Otherwise, if Op is a floating-point splat
9754 // we can splat the constant value into the whole vector then fill
9939 // Firstly, try to materialize the splat constant
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/X86/ |
| X86ISelLowering.cpp | 2308 // getMemsetStores() may create an intermediate splat (using an integer
2309 // multiply) before we splat as a vector.
5311 // after type legalization. But constant splat vectors of i64 can't make it
8221 // If this is a splat of a pair of elements, use MOVDDUP (unless the target
8813 /// Attempt to use the vbroadcast instruction to generate a splat value
8814 /// from a splat BUILD_VECTOR which uses:
8836 // See if the build vector is a repeating sequence of scalars (inc. splat).
8853 // If not a splat, are the upper sequence values zeroable?
8986 // Splat f32, i32, v4f64, v4i64 in all cases with AVX2.
8987 // For size optimization, also splat v2f64 and v2i64, and for size op
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/PowerPC/ |
| PPCISelLowering.cpp | 2089 /// specifies a splat of a single element that is suitable for input to
2090 /// one of the splat operations (VSPLTB/VSPLTH/VSPLTW/XXSPLTW/LXVDSX/etc.).
2100 // This is a splat operation if each element of the permute is the same, and
2386 /// getSplatIdxForPPCMnemonics - Return the splat index as a value that is
2406 // If ByteSize of the splat is bigger than the element size of the
2407 // build_vector, then we have a case where we are checking for a splat where
2409 // logical element of the splat (e.g. "vsplish 1" to splat {0,1}*8).
2481 // If the splat value is larger than the element value, then we can never do
2482 // this splat. The only case that we could fit the replicated bits into ou
[all...] |
