[llvm] r368183 - Recommit r367901 "[X86] Enable -x86-experimental-vector-widening-legalization by default."
Jordan Rupprecht via llvm-commits
llvm-commits at lists.llvm.org
Thu Aug 29 09:33:49 PDT 2019
Hi Craig,
It looks like we don't see any regressions in polybench with a
release @r369822.
However, we have a new regression (-20% in stanford puzzle/shootout sieve
in llvm singlesource benchmarks) somewhere between r369600 and r369679. I
hope it's not r369628 :(
I'll be continuing the root causing today
On Fri, Aug 23, 2019 at 6:42 PM Craig Topper via llvm-commits <
llvm-commits at lists.llvm.org> wrote:
> Eric,
>
> Did that fix recover any of the performance issues? I think it fixed the
> big issue in polybench.
>
> ~Craig
>
>
> On Thu, Aug 22, 2019 at 1:19 AM Craig Topper <craig.topper at gmail.com>
> wrote:
>
>> I just commited r369628 which should hopefully fix trisolv from that set
>> of tests. I haven't investigated any other tests yet.
>>
>> ~Craig
>>
>>
>> On Wed, Aug 21, 2019 at 5:48 PM Eric Christopher <echristo at gmail.com>
>> wrote:
>>
>>> FWIW one set of benchmarks that regressed for us were the polybench
>>> ones in the testsuite on Haswell and Sandybridge (Skylake was a net
>>> win iirc). Something immediately public you could take a look at.
>>>
>>> -eric
>>>
>>> On Tue, Aug 20, 2019 at 10:11 AM Eric Christopher <echristo at gmail.com>
>>> wrote:
>>> >
>>> > Thanks Craig!
>>> >
>>> > -eric
>>> >
>>> > On Mon, Aug 19, 2019 at 11:59 PM Craig Topper <craig.topper at gmail.com>
>>> wrote:
>>> > >
>>> > > -x86-experimental-vector-widening-legalization command line flag has
>>> been restored in r369332. It defaults to true which enables the new
>>> behavior. Setting it to false should hopefully restore the old behavior. I
>>> can't guarantee that though since we no tests for it. And I have no way of
>>> knowing if we break anything going foward. So hopefully we can get the
>>> issues resolved quickly and not have to depend on this for long.
>>> > >
>>> > > ~Craig
>>> > >
>>> > >
>>> > > On Mon, Aug 19, 2019 at 10:28 PM Eric Christopher <
>>> echristo at gmail.com> wrote:
>>> > >>
>>> > >> I do apologize, we've only just gotten to performance testing and
>>> the
>>> > >> numbers are pretty exciting, but unfortunately many more negatives
>>> > >> than positives. We'll definitely work with you on testing and
>>> > >> performance analysis if that will help?
>>> > >>
>>> > >> Thanks!
>>> > >>
>>> > >> -eric
>>> > >>
>>> > >> On Mon, Aug 19, 2019 at 10:23 PM Craig Topper <
>>> craig.topper at gmail.com> wrote:
>>> > >> >
>>> > >> > There have been quite a lot of follow on patches to this. A lot
>>> of them would need be reverted to get back to the old state. I can start
>>> trying to put that together.
>>> > >> >
>>> > >> > ~Craig
>>> > >> >
>>> > >> >
>>> > >> > On Mon, Aug 19, 2019 at 9:55 PM Eric Christopher via llvm-commits
>>> <llvm-commits at lists.llvm.org> wrote:
>>> > >> >>
>>> > >> >> HI Craig,
>>> > >> >>
>>> > >> >> We're seeing a rather lot of performance regressions with this
>>> enabled
>>> > >> >> by default. Is it possible to get it turned on under a command
>>> flag
>>> > >> >> for the near term while we work on getting you a pile of
>>> testcases
>>> > >> >> (some of it is Eigen and those will at least be easier as you
>>> have
>>> > >> >> access to that source :)
>>> > >> >>
>>> > >> >> Thoughts?
>>> > >> >>
>>> > >> >> Thanks!
>>> > >> >>
>>> > >> >> -eric
>>> > >> >>
>>> > >> >> On Wed, Aug 7, 2019 at 9:23 AM Craig Topper via llvm-commits
>>> > >> >> <llvm-commits at lists.llvm.org> wrote:
>>> > >> >> >
>>> > >> >> > Author: ctopper
>>> > >> >> > Date: Wed Aug 7 09:24:26 2019
>>> > >> >> > New Revision: 368183
>>> > >> >> >
>>> > >> >> > URL: http://llvm.org/viewvc/llvm-project?rev=368183&view=rev
>>> > >> >> > Log:
>>> > >> >> > Recommit r367901 "[X86] Enable
>>> -x86-experimental-vector-widening-legalization by default."
>>> > >> >> >
>>> > >> >> > The assert that caused this to be reverted should be fixed now.
>>> > >> >> >
>>> > >> >> > Original commit message:
>>> > >> >> >
>>> > >> >> > This patch changes our defualt legalization behavior for 16,
>>> 32, and
>>> > >> >> > 64 bit vectors with i8/i16/i32/i64 scalar types from promotion
>>> to
>>> > >> >> > widening. For example, v8i8 will now be widened to v16i8
>>> instead of
>>> > >> >> > promoted to v8i16. This keeps the elements widths the same and
>>> pads
>>> > >> >> > with undef elements. We believe this is a better legalization
>>> strategy.
>>> > >> >> > But it carries some issues due to the fragmented vector ISA.
>>> For
>>> > >> >> > example, i8 shifts and multiplies get widened and then later
>>> have
>>> > >> >> > to be promoted/split into vXi16 vectors.
>>> > >> >> >
>>> > >> >> > This has the potential to cause regressions so we wanted to get
>>> > >> >> > it in early in the 10.0 cycle so we have plenty of time to
>>> > >> >> > address them.
>>> > >> >> >
>>> > >> >> > Next steps will be to merge tests that explicitly test the
>>> command
>>> > >> >> > line option. And then we can remove the option and its
>>> associated
>>> > >> >> > code.
>>> > >> >> >
>>> > >> >> > Removed:
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/reduce-add-widen.ll
>>> > >> >> > Modified:
>>> > >> >> > llvm/trunk/lib/Target/X86/X86ISelLowering.cpp
>>> > >> >> > llvm/trunk/lib/Target/X86/X86TargetTransformInfo.cpp
>>> > >> >> >
>>> llvm/trunk/test/Analysis/CostModel/X86/alternate-shuffle-cost.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/arith.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/cast.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/fptosi.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/fptoui.ll
>>> > >> >> >
>>> llvm/trunk/test/Analysis/CostModel/X86/masked-intrinsic-cost.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/reduce-add.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/reduce-and.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/reduce-mul.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/reduce-or.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/reduce-smax.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/reduce-smin.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/reduce-umax.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/reduce-umin.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/reduce-xor.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/shuffle-transpose.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/sitofp.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/slm-arith-costs.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/testshiftashr.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/testshiftlshr.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/testshiftshl.ll
>>> > >> >> > llvm/trunk/test/Analysis/CostModel/X86/uitofp.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/2008-09-05-sinttofp-2xi32.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/2009-06-05-VZextByteShort.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/2011-10-19-LegelizeLoad.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/2011-12-28-vselecti8.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/2011-12-8-bitcastintprom.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/2012-01-18-vbitcast.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/2012-03-15-build_vector_wl.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/2012-07-10-extload64.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/3dnow-intrinsics.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/4char-promote.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/and-load-fold.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/atomic-unordered.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avg.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx-cvt-2.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx-fp2int.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx2-conversions.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx2-masked-gather.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx2-vbroadcast.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx512-any_extend_load.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx512-cvt.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx512-ext.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx512-intrinsics-upgrade.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx512-mask-op.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx512-trunc.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx512-vec-cmp.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx512-vec3-crash.ll
>>> > >> >> >
>>> llvm/trunk/test/CodeGen/X86/avx512bwvl-intrinsics-upgrade.ll
>>> > >> >> >
>>> llvm/trunk/test/CodeGen/X86/avx512vl-intrinsics-fast-isel.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/avx512vl-intrinsics-upgrade.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/bitcast-and-setcc-128.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/bitcast-setcc-128.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/bitcast-vector-bool.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/bitreverse.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/bswap-vector.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/buildvec-insertvec.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/combine-64bit-vec-binop.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/combine-or.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/complex-fastmath.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/cvtv2f32.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/extract-concat.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/extract-insert.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/f16c-intrinsics.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/fold-vector-sext-zext.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/insertelement-shuffle.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/known-bits.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/load-partial.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/lower-bitcast.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/madd.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/masked_compressstore.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/masked_expandload.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/masked_gather_scatter.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/masked_gather_scatter_widen.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/masked_load.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/masked_store.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/masked_store_trunc.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/masked_store_trunc_ssat.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/masked_store_trunc_usat.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/merge-consecutive-loads-256.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/mmx-arg-passing-x86-64.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/mmx-arith.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/mmx-cvt.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/mulvi32.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/oddshuffles.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/oddsubvector.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/pmaddubsw.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/pmulh.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/pointer-vector.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/pr14161.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/pr35918.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/pr40994.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/promote-vec3.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/promote.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/psubus.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/ret-mmx.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/sad.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/sadd_sat_vec.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/scalar_widen_div.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/select.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/shift-combine.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/shrink_vmul.ll
>>> > >> >> >
>>> llvm/trunk/test/CodeGen/X86/shuffle-strided-with-offset-128.ll
>>> > >> >> >
>>> llvm/trunk/test/CodeGen/X86/shuffle-strided-with-offset-256.ll
>>> > >> >> >
>>> llvm/trunk/test/CodeGen/X86/shuffle-strided-with-offset-512.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/shuffle-vs-trunc-128.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/shuffle-vs-trunc-256.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/shuffle-vs-trunc-512.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/slow-pmulld.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/sse2-intrinsics-canonical.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/sse2-vector-shifts.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/ssub_sat_vec.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/test-shrink-bug.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/trunc-ext-ld-st.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/trunc-subvector.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/uadd_sat_vec.ll
>>> > >> >> >
>>> llvm/trunk/test/CodeGen/X86/unfold-masked-merge-vector-variablemask.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/usub_sat_vec.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_cast2.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_cast3.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_ctbits.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_extract-mmx.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_fp_to_int.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_insert-5.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_insert-7.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_insert-mmx.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_int_to_fp.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_saddo.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_smulo.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_ssubo.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_uaddo.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_umulo.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vec_usubo.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-blend.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-ext-logic.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-gep.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-half-conversions.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-idiv-v2i32.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-narrow-binop.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-add.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-and-bool.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-and.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-mul.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-or-bool.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-or.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-smax.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-smin.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-umax.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-umin.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-xor-bool.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-reduce-xor.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-sext.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-shift-ashr-sub128.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-shift-by-select-loop.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-shift-lshr-sub128.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-shift-shl-sub128.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-shuffle-128-v16.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-shuffle-combining.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-trunc-packus.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-trunc-ssat.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-trunc-usat.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-trunc.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-truncate-combine.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vector-zext.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vsel-cmp-load.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vselect-avx.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vselect.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/vshift-4.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_arith-1.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_arith-2.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_arith-3.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_bitops-0.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_cast-1.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_cast-2.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_cast-3.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_cast-4.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_cast-5.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_cast-6.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_compare-1.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_conv-1.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_conv-2.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_conv-3.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_conv-4.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_load-2.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/widen_shuffle-1.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/x86-interleaved-access.ll
>>> > >> >> > llvm/trunk/test/CodeGen/X86/x86-shifts.ll
>>> > >> >> >
>>> llvm/trunk/test/Transforms/SLPVectorizer/X86/blending-shuffle.ll
>>> > >> >> > llvm/trunk/test/Transforms/SLPVectorizer/X86/fptosi.ll
>>> > >> >> > llvm/trunk/test/Transforms/SLPVectorizer/X86/fptoui.ll
>>> > >> >> >
>>> llvm/trunk/test/Transforms/SLPVectorizer/X86/insert-element-build-vector.ll
>>> > >> >> > llvm/trunk/test/Transforms/SLPVectorizer/X86/sitofp.ll
>>> > >> >> > llvm/trunk/test/Transforms/SLPVectorizer/X86/uitofp.ll
>>> > >> >> >
>>> > >> >> > Modified: llvm/trunk/lib/Target/X86/X86ISelLowering.cpp
>>> > >> >> > URL:
>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/X86ISelLowering.cpp?rev=368183&r1=368182&r2=368183&view=diff
>>> > >> >> >
>>> ==============================================================================
>>> > >> >> > --- llvm/trunk/lib/Target/X86/X86ISelLowering.cpp (original)
>>> > >> >> > +++ llvm/trunk/lib/Target/X86/X86ISelLowering.cpp Wed Aug 7
>>> 09:24:26 2019
>>> > >> >> > @@ -66,7 +66,7 @@ using namespace llvm;
>>> > >> >> > STATISTIC(NumTailCalls, "Number of tail calls");
>>> > >> >> >
>>> > >> >> > static cl::opt<bool> ExperimentalVectorWideningLegalization(
>>> > >> >> > - "x86-experimental-vector-widening-legalization",
>>> cl::init(false),
>>> > >> >> > + "x86-experimental-vector-widening-legalization",
>>> cl::init(true),
>>> > >> >> > cl::desc("Enable an experimental vector type legalization
>>> through widening "
>>> > >> >> > "rather than promotion."),
>>> > >> >> > cl::Hidden);
>>> > >> >> > @@ -40453,8 +40453,7 @@ static SDValue combineStore(SDNode *N,
>>> S
>>> > >> >> > bool NoImplicitFloatOps =
>>> F.hasFnAttribute(Attribute::NoImplicitFloat);
>>> > >> >> > bool F64IsLegal =
>>> > >> >> > !Subtarget.useSoftFloat() && !NoImplicitFloatOps &&
>>> Subtarget.hasSSE2();
>>> > >> >> > - if (((VT.isVector() && !VT.isFloatingPoint()) ||
>>> > >> >> > - (VT == MVT::i64 && F64IsLegal &&
>>> !Subtarget.is64Bit())) &&
>>> > >> >> > + if ((VT == MVT::i64 && F64IsLegal && !Subtarget.is64Bit())
>>> &&
>>> > >> >> > isa<LoadSDNode>(St->getValue()) &&
>>> > >> >> > !cast<LoadSDNode>(St->getValue())->isVolatile() &&
>>> > >> >> > St->getChain().hasOneUse() && !St->isVolatile()) {
>>> > >> >> >
>>> > >> >> > Modified: llvm/trunk/lib/Target/X86/X86TargetTransformInfo.cpp
>>> > >> >> > URL:
>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/X86/X86TargetTransformInfo.cpp?rev=368183&r1=368182&r2=368183&view=diff
>>> > >> >> >
>>> ==============================================================================
>>> > >> >> > --- llvm/trunk/lib/Target/X86/X86TargetTransformInfo.cpp
>>> (original)
>>> > >> >> > +++ llvm/trunk/lib/Target/X86/X86TargetTransformInfo.cpp Wed
>>> Aug 7 09:24:26 2019
>>> > >> >> > @@ -887,7 +887,7 @@ int X86TTIImpl::getArithmeticInstrCost(
>>> > >> >> > int X86TTIImpl::getShuffleCost(TTI::ShuffleKind Kind, Type
>>> *Tp, int Index,
>>> > >> >> > Type *SubTp) {
>>> > >> >> > // 64-bit packed float vectors (v2f32) are widened to type
>>> v4f32.
>>> > >> >> > - // 64-bit packed integer vectors (v2i32) are promoted to
>>> type v2i64.
>>> > >> >> > + // 64-bit packed integer vectors (v2i32) are widened to
>>> type v4i32.
>>> > >> >> > std::pair<int, MVT> LT = TLI->getTypeLegalizationCost(DL,
>>> Tp);
>>> > >> >> >
>>> > >> >> > // Treat Transpose as 2-op shuffles - there's no difference
>>> in lowering.
>>> > >> >> > @@ -2425,14 +2425,6 @@ int X86TTIImpl::getAddressComputationCos
>>> > >> >> >
>>> > >> >> > int X86TTIImpl::getArithmeticReductionCost(unsigned Opcode,
>>> Type *ValTy,
>>> > >> >> > bool IsPairwise) {
>>> > >> >> > -
>>> > >> >> > - std::pair<int, MVT> LT = TLI->getTypeLegalizationCost(DL,
>>> ValTy);
>>> > >> >> > -
>>> > >> >> > - MVT MTy = LT.second;
>>> > >> >> > -
>>> > >> >> > - int ISD = TLI->InstructionOpcodeToISD(Opcode);
>>> > >> >> > - assert(ISD && "Invalid opcode");
>>> > >> >> > -
>>> > >> >> > // We use the Intel Architecture Code Analyzer(IACA) to
>>> measure the throughput
>>> > >> >> > // and make it as the cost.
>>> > >> >> >
>>> > >> >> > @@ -2440,7 +2432,10 @@ int X86TTIImpl::getArithmeticReductionCo
>>> > >> >> > { ISD::FADD, MVT::v2f64, 2 },
>>> > >> >> > { ISD::FADD, MVT::v4f32, 4 },
>>> > >> >> > { ISD::ADD, MVT::v2i64, 2 }, // The data
>>> reported by the IACA tool is "1.6".
>>> > >> >> > + { ISD::ADD, MVT::v2i32, 2 }, // FIXME: chosen to be
>>> less than v4i32.
>>> > >> >> > { ISD::ADD, MVT::v4i32, 3 }, // The data
>>> reported by the IACA tool is "3.5".
>>> > >> >> > + { ISD::ADD, MVT::v2i16, 3 }, // FIXME: chosen to be
>>> less than v4i16
>>> > >> >> > + { ISD::ADD, MVT::v4i16, 4 }, // FIXME: chosen to be
>>> less than v8i16
>>> > >> >> > { ISD::ADD, MVT::v8i16, 5 },
>>> > >> >> > };
>>> > >> >> >
>>> > >> >> > @@ -2449,8 +2444,11 @@ int X86TTIImpl::getArithmeticReductionCo
>>> > >> >> > { ISD::FADD, MVT::v4f64, 5 },
>>> > >> >> > { ISD::FADD, MVT::v8f32, 7 },
>>> > >> >> > { ISD::ADD, MVT::v2i64, 1 }, // The data
>>> reported by the IACA tool is "1.5".
>>> > >> >> > + { ISD::ADD, MVT::v2i32, 2 }, // FIXME: chosen to be
>>> less than v4i32
>>> > >> >> > { ISD::ADD, MVT::v4i32, 3 }, // The data
>>> reported by the IACA tool is "3.5".
>>> > >> >> > { ISD::ADD, MVT::v4i64, 5 }, // The data
>>> reported by the IACA tool is "4.8".
>>> > >> >> > + { ISD::ADD, MVT::v2i16, 3 }, // FIXME: chosen to be
>>> less than v4i16
>>> > >> >> > + { ISD::ADD, MVT::v4i16, 4 }, // FIXME: chosen to be
>>> less than v8i16
>>> > >> >> > { ISD::ADD, MVT::v8i16, 5 },
>>> > >> >> > { ISD::ADD, MVT::v8i32, 5 },
>>> > >> >> > };
>>> > >> >> > @@ -2459,7 +2457,10 @@ int X86TTIImpl::getArithmeticReductionCo
>>> > >> >> > { ISD::FADD, MVT::v2f64, 2 },
>>> > >> >> > { ISD::FADD, MVT::v4f32, 4 },
>>> > >> >> > { ISD::ADD, MVT::v2i64, 2 }, // The data
>>> reported by the IACA tool is "1.6".
>>> > >> >> > + { ISD::ADD, MVT::v2i32, 2 }, // FIXME: chosen to be
>>> less than v4i32
>>> > >> >> > { ISD::ADD, MVT::v4i32, 3 }, // The data
>>> reported by the IACA tool is "3.3".
>>> > >> >> > + { ISD::ADD, MVT::v2i16, 2 }, // The data
>>> reported by the IACA tool is "4.3".
>>> > >> >> > + { ISD::ADD, MVT::v4i16, 3 }, // The data
>>> reported by the IACA tool is "4.3".
>>> > >> >> > { ISD::ADD, MVT::v8i16, 4 }, // The data
>>> reported by the IACA tool is "4.3".
>>> > >> >> > };
>>> > >> >> >
>>> > >> >> > @@ -2468,12 +2469,47 @@ int
>>> X86TTIImpl::getArithmeticReductionCo
>>> > >> >> > { ISD::FADD, MVT::v4f64, 3 },
>>> > >> >> > { ISD::FADD, MVT::v8f32, 4 },
>>> > >> >> > { ISD::ADD, MVT::v2i64, 1 }, // The data
>>> reported by the IACA tool is "1.5".
>>> > >> >> > + { ISD::ADD, MVT::v2i32, 2 }, // FIXME: chosen to be
>>> less than v4i32
>>> > >> >> > { ISD::ADD, MVT::v4i32, 3 }, // The data
>>> reported by the IACA tool is "2.8".
>>> > >> >> > { ISD::ADD, MVT::v4i64, 3 },
>>> > >> >> > + { ISD::ADD, MVT::v2i16, 2 }, // The data
>>> reported by the IACA tool is "4.3".
>>> > >> >> > + { ISD::ADD, MVT::v4i16, 3 }, // The data
>>> reported by the IACA tool is "4.3".
>>> > >> >> > { ISD::ADD, MVT::v8i16, 4 },
>>> > >> >> > { ISD::ADD, MVT::v8i32, 5 },
>>> > >> >> > };
>>> > >> >> >
>>> > >> >> > + int ISD = TLI->InstructionOpcodeToISD(Opcode);
>>> > >> >> > + assert(ISD && "Invalid opcode");
>>> > >> >> > +
>>> > >> >> > + // Before legalizing the type, give a chance to look up
>>> illegal narrow types
>>> > >> >> > + // in the table.
>>> > >> >> > + // FIXME: Is there a better way to do this?
>>> > >> >> > + EVT VT = TLI->getValueType(DL, ValTy);
>>> > >> >> > + if (VT.isSimple()) {
>>> > >> >> > + MVT MTy = VT.getSimpleVT();
>>> > >> >> > + if (IsPairwise) {
>>> > >> >> > + if (ST->hasAVX())
>>> > >> >> > + if (const auto *Entry =
>>> CostTableLookup(AVX1CostTblPairWise, ISD, MTy))
>>> > >> >> > + return Entry->Cost;
>>> > >> >> > +
>>> > >> >> > + if (ST->hasSSE42())
>>> > >> >> > + if (const auto *Entry =
>>> CostTableLookup(SSE42CostTblPairWise, ISD, MTy))
>>> > >> >> > + return Entry->Cost;
>>> > >> >> > + } else {
>>> > >> >> > + if (ST->hasAVX())
>>> > >> >> > + if (const auto *Entry =
>>> CostTableLookup(AVX1CostTblNoPairWise, ISD, MTy))
>>> > >> >> > + return Entry->Cost;
>>> > >> >> > +
>>> > >> >> > + if (ST->hasSSE42())
>>> > >> >> > + if (const auto *Entry =
>>> CostTableLookup(SSE42CostTblNoPairWise, ISD, MTy))
>>> > >> >> > + return Entry->Cost;
>>> > >> >> > + }
>>> > >> >> > + }
>>> > >> >> > +
>>> > >> >> > + std::pair<int, MVT> LT = TLI->getTypeLegalizationCost(DL,
>>> ValTy);
>>> > >> >> > +
>>> > >> >> > + MVT MTy = LT.second;
>>> > >> >> > +
>>> > >> >> > if (IsPairwise) {
>>> > >> >> > if (ST->hasAVX())
>>> > >> >> > if (const auto *Entry =
>>> CostTableLookup(AVX1CostTblPairWise, ISD, MTy))
>>> > >> >> >
>>> > >> >> > Modified:
>>> llvm/trunk/test/Analysis/CostModel/X86/alternate-shuffle-cost.ll
>>> > >> >> > URL:
>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/CostModel/X86/alternate-shuffle-cost.ll?rev=368183&r1=368182&r2=368183&view=diff
>>> > >> >> >
>>> ==============================================================================
>>> > >> >> > ---
>>> llvm/trunk/test/Analysis/CostModel/X86/alternate-shuffle-cost.ll (original)
>>> > >> >> > +++
>>> llvm/trunk/test/Analysis/CostModel/X86/alternate-shuffle-cost.ll Wed Aug 7
>>> 09:24:26 2019
>>> > >> >> > @@ -18,9 +18,21 @@
>>> > >> >> > ; 64-bit packed float vectors (v2f32) are widened to type
>>> v4f32.
>>> > >> >> >
>>> > >> >> > define <2 x i32> @test_v2i32(<2 x i32> %a, <2 x i32> %b) {
>>> > >> >> > -; CHECK-LABEL: 'test_v2i32'
>>> > >> >> > -; CHECK-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 0, i32 3>
>>> > >> >> > -; CHECK-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %1
>>> > >> >> > +; SSE2-LABEL: 'test_v2i32'
>>> > >> >> > +; SSE2-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 0, i32 3>
>>> > >> >> > +; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %1
>>> > >> >> > +;
>>> > >> >> > +; SSSE3-LABEL: 'test_v2i32'
>>> > >> >> > +; SSSE3-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 0, i32 3>
>>> > >> >> > +; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %1
>>> > >> >> > +;
>>> > >> >> > +; SSE42-LABEL: 'test_v2i32'
>>> > >> >> > +; SSE42-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 0, i32 3>
>>> > >> >> > +; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %1
>>> > >> >> > +;
>>> > >> >> > +; AVX-LABEL: 'test_v2i32'
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 0, i32 3>
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %1
>>> > >> >> > ;
>>> > >> >> > ; BTVER2-LABEL: 'test_v2i32'
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 0, i32 3>
>>> > >> >> > @@ -56,9 +68,21 @@ define <2 x float> @test_v2f32(<2 x floa
>>> > >> >> > }
>>> > >> >> >
>>> > >> >> > define <2 x i32> @test_v2i32_2(<2 x i32> %a, <2 x i32> %b) {
>>> > >> >> > -; CHECK-LABEL: 'test_v2i32_2'
>>> > >> >> > -; CHECK-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 2, i32 1>
>>> > >> >> > -; CHECK-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %1
>>> > >> >> > +; SSE2-LABEL: 'test_v2i32_2'
>>> > >> >> > +; SSE2-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 2, i32 1>
>>> > >> >> > +; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %1
>>> > >> >> > +;
>>> > >> >> > +; SSSE3-LABEL: 'test_v2i32_2'
>>> > >> >> > +; SSSE3-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 2, i32 1>
>>> > >> >> > +; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %1
>>> > >> >> > +;
>>> > >> >> > +; SSE42-LABEL: 'test_v2i32_2'
>>> > >> >> > +; SSE42-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 2, i32 1>
>>> > >> >> > +; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %1
>>> > >> >> > +;
>>> > >> >> > +; AVX-LABEL: 'test_v2i32_2'
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 2, i32 1>
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %1
>>> > >> >> > ;
>>> > >> >> > ; BTVER2-LABEL: 'test_v2i32_2'
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %1 = shufflevector <2 x i32> %a, <2 x i32> %b, <2 x i32> <i32
>>> 2, i32 1>
>>> > >> >> >
>>> > >> >> > Modified: llvm/trunk/test/Analysis/CostModel/X86/arith.ll
>>> > >> >> > URL:
>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/CostModel/X86/arith.ll?rev=368183&r1=368182&r2=368183&view=diff
>>> > >> >> >
>>> ==============================================================================
>>> > >> >> > --- llvm/trunk/test/Analysis/CostModel/X86/arith.ll (original)
>>> > >> >> > +++ llvm/trunk/test/Analysis/CostModel/X86/arith.ll Wed Aug 7
>>> 09:24:26 2019
>>> > >> >> > @@ -1342,36 +1342,32 @@ define i32 @mul(i32 %arg) {
>>> > >> >> > ; A <2 x i64> vector multiply is implemented using
>>> > >> >> > ; 3 PMULUDQ and 2 PADDS and 4 shifts.
>>> > >> >> > define void @mul_2i32() {
>>> > >> >> > -; SSE-LABEL: 'mul_2i32'
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > +; SSSE3-LABEL: 'mul_2i32'
>>> > >> >> > +; SSSE3-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > +; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > +;
>>> > >> >> > +; SSE42-LABEL: 'mul_2i32'
>>> > >> >> > +; SSE42-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > +; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > ;
>>> > >> >> > ; AVX-LABEL: 'mul_2i32'
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > ;
>>> > >> >> > -; AVX512F-LABEL: 'mul_2i32'
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > -;
>>> > >> >> > -; AVX512BW-LABEL: 'mul_2i32'
>>> > >> >> > -; AVX512BW-NEXT: Cost Model: Found an estimated cost of 8
>>> for instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > -; AVX512BW-NEXT: Cost Model: Found an estimated cost of 0
>>> for instruction: ret void
>>> > >> >> > -;
>>> > >> >> > -; AVX512DQ-LABEL: 'mul_2i32'
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 0
>>> for instruction: ret void
>>> > >> >> > +; AVX512-LABEL: 'mul_2i32'
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > ;
>>> > >> >> > ; SLM-LABEL: 'mul_2i32'
>>> > >> >> > -; SLM-NEXT: Cost Model: Found an estimated cost of 17 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > +; SLM-NEXT: Cost Model: Found an estimated cost of 11 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > ; SLM-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > ;
>>> > >> >> > ; GLM-LABEL: 'mul_2i32'
>>> > >> >> > -; GLM-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > +; GLM-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > ; GLM-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > ;
>>> > >> >> > ; BTVER2-LABEL: 'mul_2i32'
>>> > >> >> > -; BTVER2-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > +; BTVER2-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %A0 = mul <2 x i32> undef, undef
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > ;
>>> > >> >> > %A0 = mul <2 x i32> undef, undef
>>> > >> >> >
>>> > >> >> > Modified: llvm/trunk/test/Analysis/CostModel/X86/cast.ll
>>> > >> >> > URL:
>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/CostModel/X86/cast.ll?rev=368183&r1=368182&r2=368183&view=diff
>>> > >> >> >
>>> ==============================================================================
>>> > >> >> > --- llvm/trunk/test/Analysis/CostModel/X86/cast.ll (original)
>>> > >> >> > +++ llvm/trunk/test/Analysis/CostModel/X86/cast.ll Wed Aug 7
>>> 09:24:26 2019
>>> > >> >> > @@ -315,10 +315,10 @@ define void @sitofp4(<4 x i1> %a, <4 x i
>>> > >> >> > ; SSE-LABEL: 'sitofp4'
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: %A1 = sitofp <4 x i1> %a to <4 x float>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 40 for
>>> instruction: %A2 = sitofp <4 x i1> %a to <4 x double>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: %B1 = sitofp <4 x i8> %b to <4 x float>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 40 for
>>> instruction: %B2 = sitofp <4 x i8> %b to <4 x double>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: %C1 = sitofp <4 x i16> %c to <4 x float>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 40 for
>>> instruction: %C2 = sitofp <4 x i16> %c to <4 x double>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %B1 = sitofp <4 x i8> %b to <4 x float>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 160 for
>>> instruction: %B2 = sitofp <4 x i8> %b to <4 x double>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 15 for
>>> instruction: %C1 = sitofp <4 x i16> %c to <4 x float>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 80 for
>>> instruction: %C2 = sitofp <4 x i16> %c to <4 x double>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: %D1 = sitofp <4 x i32> %d to <4 x float>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 40 for
>>> instruction: %D2 = sitofp <4 x i32> %d to <4 x double>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > @@ -359,7 +359,7 @@ define void @sitofp4(<4 x i1> %a, <4 x i
>>> > >> >> > define void @sitofp8(<8 x i1> %a, <8 x i8> %b, <8 x i16> %c,
>>> <8 x i32> %d) {
>>> > >> >> > ; SSE-LABEL: 'sitofp8'
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 15 for
>>> instruction: %A1 = sitofp <8 x i1> %a to <8 x float>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 15 for
>>> instruction: %B1 = sitofp <8 x i8> %b to <8 x float>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %B1 = sitofp <8 x i8> %b to <8 x float>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 15 for
>>> instruction: %C1 = sitofp <8 x i16> %c to <8 x float>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 10 for
>>> instruction: %D1 = sitofp <8 x i32> %d to <8 x float>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > @@ -390,9 +390,9 @@ define void @uitofp4(<4 x i1> %a, <4 x i
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %A1 = uitofp <4 x i1> %a to <4 x float>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 40 for
>>> instruction: %A2 = uitofp <4 x i1> %a to <4 x double>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %B1 = uitofp <4 x i8> %b to <4 x float>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 40 for
>>> instruction: %B2 = uitofp <4 x i8> %b to <4 x double>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %C1 = uitofp <4 x i16> %c to <4 x float>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 40 for
>>> instruction: %C2 = uitofp <4 x i16> %c to <4 x double>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 160 for
>>> instruction: %B2 = uitofp <4 x i8> %b to <4 x double>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 15 for
>>> instruction: %C1 = uitofp <4 x i16> %c to <4 x float>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 80 for
>>> instruction: %C2 = uitofp <4 x i16> %c to <4 x double>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %D1 = uitofp <4 x i32> %d to <4 x float>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 40 for
>>> instruction: %D2 = uitofp <4 x i32> %d to <4 x double>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > @@ -433,7 +433,7 @@ define void @uitofp4(<4 x i1> %a, <4 x i
>>> > >> >> > define void @uitofp8(<8 x i1> %a, <8 x i8> %b, <8 x i16> %c,
>>> <8 x i32> %d) {
>>> > >> >> > ; SSE-LABEL: 'uitofp8'
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 15 for
>>> instruction: %A1 = uitofp <8 x i1> %a to <8 x float>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 15 for
>>> instruction: %B1 = uitofp <8 x i8> %b to <8 x float>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %B1 = uitofp <8 x i8> %b to <8 x float>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 15 for
>>> instruction: %C1 = uitofp <8 x i16> %c to <8 x float>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 16 for
>>> instruction: %D1 = uitofp <8 x i32> %d to <8 x float>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> >
>>> > >> >> > Modified: llvm/trunk/test/Analysis/CostModel/X86/fptosi.ll
>>> > >> >> > URL:
>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/CostModel/X86/fptosi.ll?rev=368183&r1=368182&r2=368183&view=diff
>>> > >> >> >
>>> ==============================================================================
>>> > >> >> > --- llvm/trunk/test/Analysis/CostModel/X86/fptosi.ll (original)
>>> > >> >> > +++ llvm/trunk/test/Analysis/CostModel/X86/fptosi.ll Wed Aug
>>> 7 09:24:26 2019
>>> > >> >> > @@ -92,35 +92,28 @@ define i32 @fptosi_double_i32(i32 %arg)
>>> > >> >> > define i32 @fptosi_double_i16(i32 %arg) {
>>> > >> >> > ; SSE-LABEL: 'fptosi_double_i16'
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I16 = fptosi double undef to i16
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I16 = fptosi <2 x double> undef to <2 x i16>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 13 for
>>> instruction: %V4I16 = fptosi <4 x double> undef to <4 x i16>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 27 for
>>> instruction: %V8I16 = fptosi <8 x double> undef to <8 x i16>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2I16 = fptosi <2 x double> undef to <2 x i16>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V4I16 = fptosi <4 x double> undef to <4 x i16>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 7 for
>>> instruction: %V8I16 = fptosi <8 x double> undef to <8 x i16>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > ; AVX-LABEL: 'fptosi_double_i16'
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I16 = fptosi double undef to i16
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I16 = fptosi <2 x double> undef to <2 x i16>
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2I16 = fptosi <2 x double> undef to <2 x i16>
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I16 = fptosi <4 x double> undef to <4 x i16>
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V8I16 = fptosi <8 x double> undef to <8 x i16>
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > -; AVX512F-LABEL: 'fptosi_double_i16'
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I16 = fptosi double undef to i16
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I16 = fptosi <2 x double> undef to <2 x i16>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I16 = fptosi <4 x double> undef to <4 x i16>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I16 = fptosi <8 x double> undef to <8 x i16>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; AVX512DQ-LABEL: 'fptosi_double_i16'
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %I16 = fptosi double undef to i16
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V2I16 = fptosi <2 x double> undef to <2 x i16>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V4I16 = fptosi <4 x double> undef to <4 x i16>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V8I16 = fptosi <8 x double> undef to <8 x i16>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 0
>>> for instruction: ret i32 undef
>>> > >> >> > +; AVX512-LABEL: 'fptosi_double_i16'
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I16 = fptosi double undef to i16
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2I16 = fptosi <2 x double> undef to <2 x i16>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I16 = fptosi <4 x double> undef to <4 x i16>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I16 = fptosi <8 x double> undef to <8 x i16>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > ; BTVER2-LABEL: 'fptosi_double_i16'
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I16 = fptosi double undef to i16
>>> > >> >> > -; BTVER2-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I16 = fptosi <2 x double> undef to <2 x i16>
>>> > >> >> > +; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2I16 = fptosi <2 x double> undef to <2 x i16>
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I16 = fptosi <4 x double> undef to <4 x i16>
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V8I16 = fptosi <8 x double> undef to <8 x i16>
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > @@ -143,29 +136,22 @@ define i32 @fptosi_double_i8(i32 %arg) {
>>> > >> >> > ; AVX-LABEL: 'fptosi_double_i8'
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I8 = fptosi double undef to i8
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I8 = fptosi <2 x double> undef to <2 x i8>
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I8 = fptosi <4 x double> undef to <4 x i8>
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V8I8 = fptosi <8 x double> undef to <8 x i8>
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V4I8 = fptosi <4 x double> undef to <4 x i8>
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 25 for
>>> instruction: %V8I8 = fptosi <8 x double> undef to <8 x i8>
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > -; AVX512F-LABEL: 'fptosi_double_i8'
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I8 = fptosi double undef to i8
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I8 = fptosi <2 x double> undef to <2 x i8>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I8 = fptosi <4 x double> undef to <4 x i8>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I8 = fptosi <8 x double> undef to <8 x i8>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; AVX512DQ-LABEL: 'fptosi_double_i8'
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %I8 = fptosi double undef to i8
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V2I8 = fptosi <2 x double> undef to <2 x i8>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V4I8 = fptosi <4 x double> undef to <4 x i8>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V8I8 = fptosi <8 x double> undef to <8 x i8>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 0
>>> for instruction: ret i32 undef
>>> > >> >> > +; AVX512-LABEL: 'fptosi_double_i8'
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I8 = fptosi double undef to i8
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2I8 = fptosi <2 x double> undef to <2 x i8>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I8 = fptosi <4 x double> undef to <4 x i8>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I8 = fptosi <8 x double> undef to <8 x i8>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > ; BTVER2-LABEL: 'fptosi_double_i8'
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I8 = fptosi double undef to i8
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I8 = fptosi <2 x double> undef to <2 x i8>
>>> > >> >> > -; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I8 = fptosi <4 x double> undef to <4 x i8>
>>> > >> >> > -; BTVER2-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V8I8 = fptosi <8 x double> undef to <8 x i8>
>>> > >> >> > +; BTVER2-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V4I8 = fptosi <4 x double> undef to <4 x i8>
>>> > >> >> > +; BTVER2-NEXT: Cost Model: Found an estimated cost of 25 for
>>> instruction: %V8I8 = fptosi <8 x double> undef to <8 x i8>
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > %I8 = fptosi double undef to i8
>>> > >> >> > @@ -285,9 +271,9 @@ define i32 @fptosi_float_i16(i32 %arg) {
>>> > >> >> > define i32 @fptosi_float_i8(i32 %arg) {
>>> > >> >> > ; SSE-LABEL: 'fptosi_float_i8'
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I8 = fptosi float undef to i8
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I8 = fptosi <4 x float> undef to <4 x i8>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V8I8 = fptosi <8 x float> undef to <8 x i8>
>>> > >> >> > -; SSE-NEXT: Cost Model: Found an estimated cost of 7 for
>>> instruction: %V16I8 = fptosi <16 x float> undef to <16 x i8>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V4I8 = fptosi <4 x float> undef to <4 x i8>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 25 for
>>> instruction: %V8I8 = fptosi <8 x float> undef to <8 x i8>
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 51 for
>>> instruction: %V16I8 = fptosi <16 x float> undef to <16 x i8>
>>> > >> >> > ; SSE-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > ; AVX-LABEL: 'fptosi_float_i8'
>>> > >> >> >
>>> > >> >> > Modified: llvm/trunk/test/Analysis/CostModel/X86/fptoui.ll
>>> > >> >> > URL:
>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/CostModel/X86/fptoui.ll?rev=368183&r1=368182&r2=368183&view=diff
>>> > >> >> >
>>> ==============================================================================
>>> > >> >> > --- llvm/trunk/test/Analysis/CostModel/X86/fptoui.ll (original)
>>> > >> >> > +++ llvm/trunk/test/Analysis/CostModel/X86/fptoui.ll Wed Aug
>>> 7 09:24:26 2019
>>> > >> >> > @@ -68,19 +68,12 @@ define i32 @fptoui_double_i32(i32 %arg)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 33 for
>>> instruction: %V8I32 = fptoui <8 x double> undef to <8 x i32>
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > -; AVX512F-LABEL: 'fptoui_double_i32'
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I32 = fptoui double undef to i32
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I32 = fptoui <2 x double> undef to <2 x i32>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I32 = fptoui <4 x double> undef to <4 x i32>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I32 = fptoui <8 x double> undef to <8 x i32>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; AVX512DQ-LABEL: 'fptoui_double_i32'
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %I32 = fptoui double undef to i32
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V2I32 = fptoui <2 x double> undef to <2 x i32>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V4I32 = fptoui <4 x double> undef to <4 x i32>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V8I32 = fptoui <8 x double> undef to <8 x i32>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 0
>>> for instruction: ret i32 undef
>>> > >> >> > +; AVX512-LABEL: 'fptoui_double_i32'
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I32 = fptoui double undef to i32
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2I32 = fptoui <2 x double> undef to <2 x i32>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I32 = fptoui <4 x double> undef to <4 x i32>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I32 = fptoui <8 x double> undef to <8 x i32>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > ; BTVER2-LABEL: 'fptoui_double_i32'
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I32 = fptoui double undef to i32
>>> > >> >> > @@ -106,30 +99,23 @@ define i32 @fptoui_double_i16(i32 %arg)
>>> > >> >> > ;
>>> > >> >> > ; AVX-LABEL: 'fptoui_double_i16'
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I16 = fptoui double undef to i16
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I16 = fptoui <2 x double> undef to <2 x i16>
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V4I16 = fptoui <4 x double> undef to <4 x i16>
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 25 for
>>> instruction: %V8I16 = fptoui <8 x double> undef to <8 x i16>
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2I16 = fptoui <2 x double> undef to <2 x i16>
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I16 = fptoui <4 x double> undef to <4 x i16>
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V8I16 = fptoui <8 x double> undef to <8 x i16>
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > -; AVX512F-LABEL: 'fptoui_double_i16'
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I16 = fptoui double undef to i16
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I16 = fptoui <2 x double> undef to <2 x i16>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I16 = fptoui <4 x double> undef to <4 x i16>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %V8I16 = fptoui <8 x double> undef to <8 x i16>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; AVX512DQ-LABEL: 'fptoui_double_i16'
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %I16 = fptoui double undef to i16
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V2I16 = fptoui <2 x double> undef to <2 x i16>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V4I16 = fptoui <4 x double> undef to <4 x i16>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 2
>>> for instruction: %V8I16 = fptoui <8 x double> undef to <8 x i16>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 0
>>> for instruction: ret i32 undef
>>> > >> >> > +; AVX512-LABEL: 'fptoui_double_i16'
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I16 = fptoui double undef to i16
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2I16 = fptoui <2 x double> undef to <2 x i16>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I16 = fptoui <4 x double> undef to <4 x i16>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %V8I16 = fptoui <8 x double> undef to <8 x i16>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > ; BTVER2-LABEL: 'fptoui_double_i16'
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I16 = fptoui double undef to i16
>>> > >> >> > -; BTVER2-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I16 = fptoui <2 x double> undef to <2 x i16>
>>> > >> >> > -; BTVER2-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V4I16 = fptoui <4 x double> undef to <4 x i16>
>>> > >> >> > -; BTVER2-NEXT: Cost Model: Found an estimated cost of 25 for
>>> instruction: %V8I16 = fptoui <8 x double> undef to <8 x i16>
>>> > >> >> > +; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2I16 = fptoui <2 x double> undef to <2 x i16>
>>> > >> >> > +; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I16 = fptoui <4 x double> undef to <4 x i16>
>>> > >> >> > +; BTVER2-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V8I16 = fptoui <8 x double> undef to <8 x i16>
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > %I16 = fptoui double undef to i16
>>> > >> >> > @@ -154,19 +140,12 @@ define i32 @fptoui_double_i8(i32 %arg) {
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 25 for
>>> instruction: %V8I8 = fptoui <8 x double> undef to <8 x i8>
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > -; AVX512F-LABEL: 'fptoui_double_i8'
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I8 = fptoui double undef to i8
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I8 = fptoui <2 x double> undef to <2 x i8>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I8 = fptoui <4 x double> undef to <4 x i8>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %V8I8 = fptoui <8 x double> undef to <8 x i8>
>>> > >> >> > -; AVX512F-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; AVX512DQ-LABEL: 'fptoui_double_i8'
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %I8 = fptoui double undef to i8
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V2I8 = fptoui <2 x double> undef to <2 x i8>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 1
>>> for instruction: %V4I8 = fptoui <4 x double> undef to <4 x i8>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 2
>>> for instruction: %V8I8 = fptoui <8 x double> undef to <8 x i8>
>>> > >> >> > -; AVX512DQ-NEXT: Cost Model: Found an estimated cost of 0
>>> for instruction: ret i32 undef
>>> > >> >> > +; AVX512-LABEL: 'fptoui_double_i8'
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I8 = fptoui double undef to i8
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2I8 = fptoui <2 x double> undef to <2 x i8>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I8 = fptoui <4 x double> undef to <4 x i8>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %V8I8 = fptoui <8 x double> undef to <8 x i8>
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > ; BTVER2-LABEL: 'fptoui_double_i8'
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I8 = fptoui double undef to i8
>>> > >> >> > @@ -277,7 +256,7 @@ define i32 @fptoui_float_i16(i32 %arg) {
>>> > >> >> > ;
>>> > >> >> > ; AVX-LABEL: 'fptoui_float_i16'
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I16 = fptoui float undef to i16
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V4I16 = fptoui <4 x float> undef to <4 x i16>
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I16 = fptoui <4 x float> undef to <4 x i16>
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I16 = fptoui <8 x float> undef to <8 x i16>
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V16I16 = fptoui <16 x float> undef to <16 x i16>
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > @@ -291,7 +270,7 @@ define i32 @fptoui_float_i16(i32 %arg) {
>>> > >> >> > ;
>>> > >> >> > ; BTVER2-LABEL: 'fptoui_float_i16'
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I16 = fptoui float undef to i16
>>> > >> >> > -; BTVER2-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V4I16 = fptoui <4 x float> undef to <4 x i16>
>>> > >> >> > +; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I16 = fptoui <4 x float> undef to <4 x i16>
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I16 = fptoui <8 x float> undef to <8 x i16>
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V16I16 = fptoui <16 x float> undef to <16 x i16>
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > @@ -314,8 +293,8 @@ define i32 @fptoui_float_i8(i32 %arg) {
>>> > >> >> > ; AVX-LABEL: 'fptoui_float_i8'
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I8 = fptoui float undef to i8
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V4I8 = fptoui <4 x float> undef to <4 x i8>
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I8 = fptoui <8 x float> undef to <8 x i8>
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V16I8 = fptoui <16 x float> undef to <16 x i8>
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 24 for
>>> instruction: %V8I8 = fptoui <8 x float> undef to <8 x i8>
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 49 for
>>> instruction: %V16I8 = fptoui <16 x float> undef to <16 x i8>
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > ; AVX512-LABEL: 'fptoui_float_i8'
>>> > >> >> > @@ -328,8 +307,8 @@ define i32 @fptoui_float_i8(i32 %arg) {
>>> > >> >> > ; BTVER2-LABEL: 'fptoui_float_i8'
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %I8 = fptoui float undef to i8
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V4I8 = fptoui <4 x float> undef to <4 x i8>
>>> > >> >> > -; BTVER2-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I8 = fptoui <8 x float> undef to <8 x i8>
>>> > >> >> > -; BTVER2-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V16I8 = fptoui <16 x float> undef to <16 x i8>
>>> > >> >> > +; BTVER2-NEXT: Cost Model: Found an estimated cost of 24 for
>>> instruction: %V8I8 = fptoui <8 x float> undef to <8 x i8>
>>> > >> >> > +; BTVER2-NEXT: Cost Model: Found an estimated cost of 49 for
>>> instruction: %V16I8 = fptoui <16 x float> undef to <16 x i8>
>>> > >> >> > ; BTVER2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > ;
>>> > >> >> > %I8 = fptoui float undef to i8
>>> > >> >> >
>>> > >> >> > Modified:
>>> llvm/trunk/test/Analysis/CostModel/X86/masked-intrinsic-cost.ll
>>> > >> >> > URL:
>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/CostModel/X86/masked-intrinsic-cost.ll?rev=368183&r1=368182&r2=368183&view=diff
>>> > >> >> >
>>> ==============================================================================
>>> > >> >> > ---
>>> llvm/trunk/test/Analysis/CostModel/X86/masked-intrinsic-cost.ll (original)
>>> > >> >> > +++
>>> llvm/trunk/test/Analysis/CostModel/X86/masked-intrinsic-cost.ll Wed Aug 7
>>> 09:24:26 2019
>>> > >> >> > @@ -52,7 +52,7 @@ define i32 @masked_load() {
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 4 for
>>> instruction: %V16I32 = call <16 x i32>
>>> @llvm.masked.load.v16i32.p0v16i32(<16 x i32>* undef, i32 1, <16 x i1>
>>> undef, <16 x i32> undef)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %V8I32 = call <8 x i32> @llvm.masked.load.v8i32.p0v8i32(<8 x
>>> i32>* undef, i32 1, <8 x i1> undef, <8 x i32> undef)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %V4I32 = call <4 x i32> @llvm.masked.load.v4i32.p0v4i32(<4 x
>>> i32>* undef, i32 1, <4 x i1> undef, <4 x i32> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 4 for
>>> instruction: %V2I32 = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* undef, i32 1, <2 x i1> undef, <2 x i32> undef)
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V2I32 = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* undef, i32 1, <2 x i1> undef, <2 x i32> undef)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 128 for
>>> instruction: %V32I16 = call <32 x i16>
>>> @llvm.masked.load.v32i16.p0v32i16(<32 x i16>* undef, i32 1, <32 x i1>
>>> undef, <32 x i16> undef)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 64 for
>>> instruction: %V16I16 = call <16 x i16>
>>> @llvm.masked.load.v16i16.p0v16i16(<16 x i16>* undef, i32 1, <16 x i1>
>>> undef, <16 x i16> undef)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 32 for
>>> instruction: %V8I16 = call <8 x i16> @llvm.masked.load.v8i16.p0v8i16(<8 x
>>> i16>* undef, i32 1, <8 x i1> undef, <8 x i16> undef)
>>> > >> >> > @@ -79,7 +79,7 @@ define i32 @masked_load() {
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V16I32 = call <16 x i32>
>>> @llvm.masked.load.v16i32.p0v16i32(<16 x i32>* undef, i32 1, <16 x i1>
>>> undef, <16 x i32> undef)
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I32 = call <8 x i32> @llvm.masked.load.v8i32.p0v8i32(<8 x
>>> i32>* undef, i32 1, <8 x i1> undef, <8 x i32> undef)
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I32 = call <4 x i32> @llvm.masked.load.v4i32.p0v4i32(<4 x
>>> i32>* undef, i32 1, <4 x i1> undef, <4 x i32> undef)
>>> > >> >> > -; KNL-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V2I32 = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* undef, i32 1, <2 x i1> undef, <2 x i32> undef)
>>> > >> >> > +; KNL-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: %V2I32 = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* undef, i32 1, <2 x i1> undef, <2 x i32> undef)
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 128 for
>>> instruction: %V32I16 = call <32 x i16>
>>> @llvm.masked.load.v32i16.p0v32i16(<32 x i16>* undef, i32 1, <32 x i1>
>>> undef, <32 x i16> undef)
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 64 for
>>> instruction: %V16I16 = call <16 x i16>
>>> @llvm.masked.load.v16i16.p0v16i16(<16 x i16>* undef, i32 1, <16 x i1>
>>> undef, <16 x i16> undef)
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 32 for
>>> instruction: %V8I16 = call <8 x i16> @llvm.masked.load.v8i16.p0v8i16(<8 x
>>> i16>* undef, i32 1, <8 x i1> undef, <8 x i16> undef)
>>> > >> >> > @@ -106,15 +106,15 @@ define i32 @masked_load() {
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V16I32 = call <16 x i32>
>>> @llvm.masked.load.v16i32.p0v16i32(<16 x i32>* undef, i32 1, <16 x i1>
>>> undef, <16 x i32> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I32 = call <8 x i32> @llvm.masked.load.v8i32.p0v8i32(<8 x
>>> i32>* undef, i32 1, <8 x i1> undef, <8 x i32> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V4I32 = call <4 x i32> @llvm.masked.load.v4i32.p0v4i32(<4 x
>>> i32>* undef, i32 1, <4 x i1> undef, <4 x i32> undef)
>>> > >> >> > -; SKX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V2I32 = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* undef, i32 1, <2 x i1> undef, <2 x i32> undef)
>>> > >> >> > +; SKX-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: %V2I32 = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* undef, i32 1, <2 x i1> undef, <2 x i32> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V32I16 = call <32 x i16>
>>> @llvm.masked.load.v32i16.p0v32i16(<32 x i16>* undef, i32 1, <32 x i1>
>>> undef, <32 x i16> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V16I16 = call <16 x i16>
>>> @llvm.masked.load.v16i16.p0v16i16(<16 x i16>* undef, i32 1, <16 x i1>
>>> undef, <16 x i16> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V8I16 = call <8 x i16> @llvm.masked.load.v8i16.p0v8i16(<8 x
>>> i16>* undef, i32 1, <8 x i1> undef, <8 x i16> undef)
>>> > >> >> > -; SKX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V4I16 = call <4 x i16> @llvm.masked.load.v4i16.p0v4i16(<4 x
>>> i16>* undef, i32 1, <4 x i1> undef, <4 x i16> undef)
>>> > >> >> > +; SKX-NEXT: Cost Model: Found an estimated cost of 9 for
>>> instruction: %V4I16 = call <4 x i16> @llvm.masked.load.v4i16.p0v4i16(<4 x
>>> i16>* undef, i32 1, <4 x i1> undef, <4 x i16> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V64I8 = call <64 x i8> @llvm.masked.load.v64i8.p0v64i8(<64 x
>>> i8>* undef, i32 1, <64 x i1> undef, <64 x i8> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V32I8 = call <32 x i8> @llvm.masked.load.v32i8.p0v32i8(<32 x
>>> i8>* undef, i32 1, <32 x i1> undef, <32 x i8> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V16I8 = call <16 x i8> @llvm.masked.load.v16i8.p0v16i8(<16 x
>>> i8>* undef, i32 1, <16 x i1> undef, <16 x i8> undef)
>>> > >> >> > -; SKX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V8I8 = call <8 x i8> @llvm.masked.load.v8i8.p0v8i8(<8 x i8>*
>>> undef, i32 1, <8 x i1> undef, <8 x i8> undef)
>>> > >> >> > +; SKX-NEXT: Cost Model: Found an estimated cost of 17 for
>>> instruction: %V8I8 = call <8 x i8> @llvm.masked.load.v8i8.p0v8i8(<8 x i8>*
>>> undef, i32 1, <8 x i1> undef, <8 x i8> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 0
>>> > >> >> > ;
>>> > >> >> > %V8F64 = call <8 x double>
>>> @llvm.masked.load.v8f64.p0v8f64(<8 x double>* undef, i32 1, <8 x i1> undef,
>>> <8 x double> undef)
>>> > >> >> > @@ -194,7 +194,7 @@ define i32 @masked_store() {
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 16 for
>>> instruction: call void @llvm.masked.store.v16i32.p0v16i32(<16 x i32> undef,
>>> <16 x i32>* undef, i32 1, <16 x i1> undef)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: call void @llvm.masked.store.v8i32.p0v8i32(<8 x i32> undef, <8
>>> x i32>* undef, i32 1, <8 x i1> undef)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: call void @llvm.masked.store.v4i32.p0v4i32(<4 x i32> undef, <4
>>> x i32>* undef, i32 1, <4 x i1> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 10 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> undef, <2
>>> x i32>* undef, i32 1, <2 x i1> undef)
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> undef, <2
>>> x i32>* undef, i32 1, <2 x i1> undef)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 128 for
>>> instruction: call void @llvm.masked.store.v32i16.p0v32i16(<32 x i16> undef,
>>> <32 x i16>* undef, i32 1, <32 x i1> undef)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 64 for
>>> instruction: call void @llvm.masked.store.v16i16.p0v16i16(<16 x i16> undef,
>>> <16 x i16>* undef, i32 1, <16 x i1> undef)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 32 for
>>> instruction: call void @llvm.masked.store.v8i16.p0v8i16(<8 x i16> undef, <8
>>> x i16>* undef, i32 1, <8 x i1> undef)
>>> > >> >> > @@ -221,7 +221,7 @@ define i32 @masked_store() {
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v16i32.p0v16i32(<16 x i32> undef,
>>> <16 x i32>* undef, i32 1, <16 x i1> undef)
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v8i32.p0v8i32(<8 x i32> undef, <8
>>> x i32>* undef, i32 1, <8 x i1> undef)
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v4i32.p0v4i32(<4 x i32> undef, <4
>>> x i32>* undef, i32 1, <4 x i1> undef)
>>> > >> >> > -; KNL-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> undef, <2
>>> x i32>* undef, i32 1, <2 x i1> undef)
>>> > >> >> > +; KNL-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> undef, <2
>>> x i32>* undef, i32 1, <2 x i1> undef)
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 128 for
>>> instruction: call void @llvm.masked.store.v32i16.p0v32i16(<32 x i16> undef,
>>> <32 x i16>* undef, i32 1, <32 x i1> undef)
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 64 for
>>> instruction: call void @llvm.masked.store.v16i16.p0v16i16(<16 x i16> undef,
>>> <16 x i16>* undef, i32 1, <16 x i1> undef)
>>> > >> >> > ; KNL-NEXT: Cost Model: Found an estimated cost of 32 for
>>> instruction: call void @llvm.masked.store.v8i16.p0v8i16(<8 x i16> undef, <8
>>> x i16>* undef, i32 1, <8 x i1> undef)
>>> > >> >> > @@ -248,15 +248,15 @@ define i32 @masked_store() {
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v16i32.p0v16i32(<16 x i32> undef,
>>> <16 x i32>* undef, i32 1, <16 x i1> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v8i32.p0v8i32(<8 x i32> undef, <8
>>> x i32>* undef, i32 1, <8 x i1> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v4i32.p0v4i32(<4 x i32> undef, <4
>>> x i32>* undef, i32 1, <4 x i1> undef)
>>> > >> >> > -; SKX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> undef, <2
>>> x i32>* undef, i32 1, <2 x i1> undef)
>>> > >> >> > +; SKX-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> undef, <2
>>> x i32>* undef, i32 1, <2 x i1> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v32i16.p0v32i16(<32 x i16> undef,
>>> <32 x i16>* undef, i32 1, <32 x i1> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v16i16.p0v16i16(<16 x i16> undef,
>>> <16 x i16>* undef, i32 1, <16 x i1> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v8i16.p0v8i16(<8 x i16> undef, <8
>>> x i16>* undef, i32 1, <8 x i1> undef)
>>> > >> >> > -; SKX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: call void @llvm.masked.store.v4i16.p0v4i16(<4 x i16> undef, <4
>>> x i16>* undef, i32 1, <4 x i1> undef)
>>> > >> >> > +; SKX-NEXT: Cost Model: Found an estimated cost of 9 for
>>> instruction: call void @llvm.masked.store.v4i16.p0v4i16(<4 x i16> undef, <4
>>> x i16>* undef, i32 1, <4 x i1> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v64i8.p0v64i8(<64 x i8> undef,
>>> <64 x i8>* undef, i32 1, <64 x i1> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v32i8.p0v32i8(<32 x i8> undef,
>>> <32 x i8>* undef, i32 1, <32 x i1> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: call void @llvm.masked.store.v16i8.p0v16i8(<16 x i8> undef,
>>> <16 x i8>* undef, i32 1, <16 x i1> undef)
>>> > >> >> > -; SKX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: call void @llvm.masked.store.v8i8.p0v8i8(<8 x i8> undef, <8 x
>>> i8>* undef, i32 1, <8 x i1> undef)
>>> > >> >> > +; SKX-NEXT: Cost Model: Found an estimated cost of 17 for
>>> instruction: call void @llvm.masked.store.v8i8.p0v8i8(<8 x i8> undef, <8 x
>>> i8>* undef, i32 1, <8 x i1> undef)
>>> > >> >> > ; SKX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 0
>>> > >> >> > ;
>>> > >> >> > call void @llvm.masked.store.v8f64.p0v8f64(<8 x double>
>>> undef, <8 x double>* undef, i32 1, <8 x i1> undef)
>>> > >> >> > @@ -960,15 +960,10 @@ define <8 x float> @test4(<8 x i32> %tri
>>> > >> >> > }
>>> > >> >> >
>>> > >> >> > define void @test5(<2 x i32> %trigger, <2 x float>* %addr, <2
>>> x float> %val) {
>>> > >> >> > -; SSE2-LABEL: 'test5'
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 7 for
>>> instruction: call void @llvm.masked.store.v2f32.p0v2f32(<2 x float> %val,
>>> <2 x float>* %addr, i32 4, <2 x i1> %mask)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > -;
>>> > >> >> > -; SSE42-LABEL: 'test5'
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 7 for
>>> instruction: call void @llvm.masked.store.v2f32.p0v2f32(<2 x float> %val,
>>> <2 x float>* %addr, i32 4, <2 x i1> %mask)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > +; SSE-LABEL: 'test5'
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 7 for
>>> instruction: call void @llvm.masked.store.v2f32.p0v2f32(<2 x float> %val,
>>> <2 x float>* %addr, i32 4, <2 x i1> %mask)
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > ;
>>> > >> >> > ; AVX-LABEL: 'test5'
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > @@ -986,24 +981,19 @@ define void @test5(<2 x i32> %trigger, <
>>> > >> >> > }
>>> > >> >> >
>>> > >> >> > define void @test6(<2 x i32> %trigger, <2 x i32>* %addr, <2 x
>>> i32> %val) {
>>> > >> >> > -; SSE2-LABEL: 'test6'
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> %val, <2
>>> x i32>* %addr, i32 4, <2 x i1> %mask)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > -;
>>> > >> >> > -; SSE42-LABEL: 'test6'
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> %val, <2
>>> x i32>* %addr, i32 4, <2 x i1> %mask)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > +; SSE-LABEL: 'test6'
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> %val, <2
>>> x i32>* %addr, i32 4, <2 x i1> %mask)
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > ;
>>> > >> >> > ; AVX-LABEL: 'test6'
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 10 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> %val, <2
>>> x i32>* %addr, i32 4, <2 x i1> %mask)
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> %val, <2
>>> x i32>* %addr, i32 4, <2 x i1> %mask)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > ;
>>> > >> >> > ; AVX512-LABEL: 'test6'
>>> > >> >> > ; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; AVX512-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> %val, <2
>>> x i32>* %addr, i32 4, <2 x i1> %mask)
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: call void @llvm.masked.store.v2i32.p0v2i32(<2 x i32> %val, <2
>>> x i32>* %addr, i32 4, <2 x i1> %mask)
>>> > >> >> > ; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret void
>>> > >> >> > ;
>>> > >> >> > %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > @@ -1012,15 +1002,10 @@ define void @test6(<2 x i32> %trigger,
>>> <
>>> > >> >> > }
>>> > >> >> >
>>> > >> >> > define <2 x float> @test7(<2 x i32> %trigger, <2 x float>*
>>> %addr, <2 x float> %dst) {
>>> > >> >> > -; SSE2-LABEL: 'test7'
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 7 for
>>> instruction: %res = call <2 x float> @llvm.masked.load.v2f32.p0v2f32(<2 x
>>> float>* %addr, i32 4, <2 x i1> %mask, <2 x float> %dst)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x float> %res
>>> > >> >> > -;
>>> > >> >> > -; SSE42-LABEL: 'test7'
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 7 for
>>> instruction: %res = call <2 x float> @llvm.masked.load.v2f32.p0v2f32(<2 x
>>> float>* %addr, i32 4, <2 x i1> %mask, <2 x float> %dst)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x float> %res
>>> > >> >> > +; SSE-LABEL: 'test7'
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 7 for
>>> instruction: %res = call <2 x float> @llvm.masked.load.v2f32.p0v2f32(<2 x
>>> float>* %addr, i32 4, <2 x i1> %mask, <2 x float> %dst)
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x float> %res
>>> > >> >> > ;
>>> > >> >> > ; AVX-LABEL: 'test7'
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > @@ -1038,24 +1023,19 @@ define <2 x float> @test7(<2 x i32>
>>> %tri
>>> > >> >> > }
>>> > >> >> >
>>> > >> >> > define <2 x i32> @test8(<2 x i32> %trigger, <2 x i32>* %addr,
>>> <2 x i32> %dst) {
>>> > >> >> > -; SSE2-LABEL: 'test8'
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %res = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* %addr, i32 4, <2 x i1> %mask, <2 x i32> %dst)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %res
>>> > >> >> > -;
>>> > >> >> > -; SSE42-LABEL: 'test8'
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %res = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* %addr, i32 4, <2 x i1> %mask, <2 x i32> %dst)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %res
>>> > >> >> > +; SSE-LABEL: 'test8'
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %res = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* %addr, i32 4, <2 x i1> %mask, <2 x i32> %dst)
>>> > >> >> > +; SSE-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %res
>>> > >> >> > ;
>>> > >> >> > ; AVX-LABEL: 'test8'
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 4 for
>>> instruction: %res = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* %addr, i32 4, <2 x i1> %mask, <2 x i32> %dst)
>>> > >> >> > +; AVX-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %res = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* %addr, i32 4, <2 x i1> %mask, <2 x i32> %dst)
>>> > >> >> > ; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %res
>>> > >> >> > ;
>>> > >> >> > ; AVX512-LABEL: 'test8'
>>> > >> >> > ; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> > -; AVX512-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %res = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* %addr, i32 4, <2 x i1> %mask, <2 x i32> %dst)
>>> > >> >> > +; AVX512-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: %res = call <2 x i32> @llvm.masked.load.v2i32.p0v2i32(<2 x
>>> i32>* %addr, i32 4, <2 x i1> %mask, <2 x i32> %dst)
>>> > >> >> > ; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret <2 x i32> %res
>>> > >> >> > ;
>>> > >> >> > %mask = icmp eq <2 x i32> %trigger, zeroinitializer
>>> > >> >> >
>>> > >> >> > Removed:
>>> llvm/trunk/test/Analysis/CostModel/X86/reduce-add-widen.ll
>>> > >> >> > URL:
>>> http://llvm.org/viewvc/llvm-project/llvm/trunk/test/Analysis/CostModel/X86/reduce-add-widen.ll?rev=368182&view=auto
>>> > >> >> >
>>> ==============================================================================
>>> > >> >> > --- llvm/trunk/test/Analysis/CostModel/X86/reduce-add-widen.ll
>>> (original)
>>> > >> >> > +++ llvm/trunk/test/Analysis/CostModel/X86/reduce-add-widen.ll
>>> (removed)
>>> > >> >> > @@ -1,307 +0,0 @@
>>> > >> >> > -; NOTE: Assertions have been autogenerated by
>>> utils/update_analyze_test_checks.py
>>> > >> >> > -; RUN: opt < %s
>>> -x86-experimental-vector-widening-legalization -cost-model
>>> -mtriple=x86_64-apple-darwin -analyze -mattr=+sse2 | FileCheck %s
>>> --check-prefixes=CHECK,SSE,SSE2
>>> > >> >> > -; RUN: opt < %s
>>> -x86-experimental-vector-widening-legalization -cost-model
>>> -mtriple=x86_64-apple-darwin -analyze -mattr=+ssse3 | FileCheck %s
>>> --check-prefixes=CHECK,SSE,SSSE3
>>> > >> >> > -; RUN: opt < %s
>>> -x86-experimental-vector-widening-legalization -cost-model
>>> -mtriple=x86_64-apple-darwin -analyze -mattr=+sse4.2 | FileCheck %s
>>> --check-prefixes=CHECK,SSE,SSE42
>>> > >> >> > -; RUN: opt < %s
>>> -x86-experimental-vector-widening-legalization -cost-model
>>> -mtriple=x86_64-apple-darwin -analyze -mattr=+avx | FileCheck %s
>>> --check-prefixes=CHECK,AVX,AVX1
>>> > >> >> > -; RUN: opt < %s
>>> -x86-experimental-vector-widening-legalization -cost-model
>>> -mtriple=x86_64-apple-darwin -analyze -mattr=+avx2 | FileCheck %s
>>> --check-prefixes=CHECK,AVX,AVX2
>>> > >> >> > -; RUN: opt < %s
>>> -x86-experimental-vector-widening-legalization -cost-model
>>> -mtriple=x86_64-apple-darwin -analyze -mattr=+avx512f | FileCheck %s
>>> --check-prefixes=CHECK,AVX512,AVX512F
>>> > >> >> > -; RUN: opt < %s
>>> -x86-experimental-vector-widening-legalization -cost-model
>>> -mtriple=x86_64-apple-darwin -analyze -mattr=+avx512f,+avx512bw | FileCheck
>>> %s --check-prefixes=CHECK,AVX512,AVX512BW
>>> > >> >> > -; RUN: opt < %s
>>> -x86-experimental-vector-widening-legalization -cost-model
>>> -mtriple=x86_64-apple-darwin -analyze -mattr=+avx512f,+avx512dq | FileCheck
>>> %s --check-prefixes=CHECK,AVX512,AVX512DQ
>>> > >> >> > -
>>> > >> >> > -define i32 @reduce_i64(i32 %arg) {
>>> > >> >> > -; SSE2-LABEL: 'reduce_i64'
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: %V1 = call i64 @llvm.experimental.vector.reduce.add.v1i64(<1 x
>>> i64> undef)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V2 = call i64 @llvm.experimental.vector.reduce.add.v2i64(<2 x
>>> i64> undef)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 4 for
>>> instruction: %V4 = call i64 @llvm.experimental.vector.reduce.add.v4i64(<4 x
>>> i64> undef)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V8 = call i64 @llvm.experimental.vector.reduce.add.v8i64(<8 x
>>> i64> undef)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 10 for
>>> instruction: %V16 = call i64
>>> @llvm.experimental.vector.reduce.add.v16i64(<16 x i64> undef)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; SSSE3-LABEL: 'reduce_i64'
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: %V1 = call i64 @llvm.experimental.vector.reduce.add.v1i64(<1 x
>>> i64> undef)
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V2 = call i64 @llvm.experimental.vector.reduce.add.v2i64(<2 x
>>> i64> undef)
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 4 for
>>> instruction: %V4 = call i64 @llvm.experimental.vector.reduce.add.v4i64(<4 x
>>> i64> undef)
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V8 = call i64 @llvm.experimental.vector.reduce.add.v8i64(<8 x
>>> i64> undef)
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 10 for
>>> instruction: %V16 = call i64
>>> @llvm.experimental.vector.reduce.add.v16i64(<16 x i64> undef)
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; SSE42-LABEL: 'reduce_i64'
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: %V1 = call i64 @llvm.experimental.vector.reduce.add.v1i64(<1 x
>>> i64> undef)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 2 for
>>> instruction: %V2 = call i64 @llvm.experimental.vector.reduce.add.v2i64(<2 x
>>> i64> undef)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 4 for
>>> instruction: %V4 = call i64 @llvm.experimental.vector.reduce.add.v4i64(<4 x
>>> i64> undef)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %V8 = call i64 @llvm.experimental.vector.reduce.add.v8i64(<8 x
>>> i64> undef)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 16 for
>>> instruction: %V16 = call i64
>>> @llvm.experimental.vector.reduce.add.v16i64(<16 x i64> undef)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; AVX-LABEL: 'reduce_i64'
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: %V1 = call i64 @llvm.experimental.vector.reduce.add.v1i64(<1 x
>>> i64> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2 = call i64 @llvm.experimental.vector.reduce.add.v2i64(<2 x
>>> i64> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V4 = call i64 @llvm.experimental.vector.reduce.add.v4i64(<4 x
>>> i64> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V8 = call i64 @llvm.experimental.vector.reduce.add.v8i64(<8 x
>>> i64> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V16 = call i64
>>> @llvm.experimental.vector.reduce.add.v16i64(<16 x i64> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; AVX512-LABEL: 'reduce_i64'
>>> > >> >> > -; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: %V1 = call i64 @llvm.experimental.vector.reduce.add.v1i64(<1 x
>>> i64> undef)
>>> > >> >> > -; AVX512-NEXT: Cost Model: Found an estimated cost of 1 for
>>> instruction: %V2 = call i64 @llvm.experimental.vector.reduce.add.v2i64(<2 x
>>> i64> undef)
>>> > >> >> > -; AVX512-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V4 = call i64 @llvm.experimental.vector.reduce.add.v4i64(<4 x
>>> i64> undef)
>>> > >> >> > -; AVX512-NEXT: Cost Model: Found an estimated cost of 7 for
>>> instruction: %V8 = call i64 @llvm.experimental.vector.reduce.add.v8i64(<8 x
>>> i64> undef)
>>> > >> >> > -; AVX512-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %V16 = call i64
>>> @llvm.experimental.vector.reduce.add.v16i64(<16 x i64> undef)
>>> > >> >> > -; AVX512-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > - %V1 = call i64
>>> @llvm.experimental.vector.reduce.add.v1i64(<1 x i64> undef)
>>> > >> >> > - %V2 = call i64
>>> @llvm.experimental.vector.reduce.add.v2i64(<2 x i64> undef)
>>> > >> >> > - %V4 = call i64
>>> @llvm.experimental.vector.reduce.add.v4i64(<4 x i64> undef)
>>> > >> >> > - %V8 = call i64
>>> @llvm.experimental.vector.reduce.add.v8i64(<8 x i64> undef)
>>> > >> >> > - %V16 = call i64
>>> @llvm.experimental.vector.reduce.add.v16i64(<16 x i64> undef)
>>> > >> >> > - ret i32 undef
>>> > >> >> > -}
>>> > >> >> > -
>>> > >> >> > -define i32 @reduce_i32(i32 %arg) {
>>> > >> >> > -; SSE2-LABEL: 'reduce_i32'
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V2 = call i32 @llvm.experimental.vector.reduce.add.v2i32(<2 x
>>> i32> undef)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: %V4 = call i32 @llvm.experimental.vector.reduce.add.v4i32(<4 x
>>> i32> undef)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V8 = call i32 @llvm.experimental.vector.reduce.add.v8i32(<8 x
>>> i32> undef)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %V16 = call i32
>>> @llvm.experimental.vector.reduce.add.v16i32(<16 x i32> undef)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V32 = call i32
>>> @llvm.experimental.vector.reduce.add.v32i32(<32 x i32> undef)
>>> > >> >> > -; SSE2-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; SSSE3-LABEL: 'reduce_i32'
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V2 = call i32 @llvm.experimental.vector.reduce.add.v2i32(<2 x
>>> i32> undef)
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: %V4 = call i32 @llvm.experimental.vector.reduce.add.v4i32(<4 x
>>> i32> undef)
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V8 = call i32 @llvm.experimental.vector.reduce.add.v8i32(<8 x
>>> i32> undef)
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 8 for
>>> instruction: %V16 = call i32
>>> @llvm.experimental.vector.reduce.add.v16i32(<16 x i32> undef)
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V32 = call i32
>>> @llvm.experimental.vector.reduce.add.v32i32(<32 x i32> undef)
>>> > >> >> > -; SSSE3-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; SSE42-LABEL: 'reduce_i32'
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V2 = call i32 @llvm.experimental.vector.reduce.add.v2i32(<2 x
>>> i32> undef)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V4 = call i32 @llvm.experimental.vector.reduce.add.v4i32(<4 x
>>> i32> undef)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 6 for
>>> instruction: %V8 = call i32 @llvm.experimental.vector.reduce.add.v8i32(<8 x
>>> i32> undef)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 12 for
>>> instruction: %V16 = call i32
>>> @llvm.experimental.vector.reduce.add.v16i32(<16 x i32> undef)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 24 for
>>> instruction: %V32 = call i32
>>> @llvm.experimental.vector.reduce.add.v32i32(<32 x i32> undef)
>>> > >> >> > -; SSE42-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; AVX-LABEL: 'reduce_i32'
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V2 = call i32 @llvm.experimental.vector.reduce.add.v2i32(<2 x
>>> i32> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V4 = call i32 @llvm.experimental.vector.reduce.add.v4i32(<4 x
>>> i32> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 5 for
>>> instruction: %V8 = call i32 @llvm.experimental.vector.reduce.add.v8i32(<8 x
>>> i32> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 10 for
>>> instruction: %V16 = call i32
>>> @llvm.experimental.vector.reduce.add.v16i32(<16 x i32> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 20 for
>>> instruction: %V32 = call i32
>>> @llvm.experimental.vector.reduce.add.v32i32(<32 x i32> undef)
>>> > >> >> > -; AVX-NEXT: Cost Model: Found an estimated cost of 0 for
>>> instruction: ret i32 undef
>>> > >> >> > -;
>>> > >> >> > -; AVX512-LABEL: 'reduce_i32'
>>> > >> >> > -; AVX512-NEXT: Cost Model: Found an estimated cost of 3 for
>>> instruction: %V2 = call i32 @llvm.experimental.vector.reduce.add.v2i32(<2 x
>>> i32> undef)
>>> > >> >> > -; AVX512-NEXT: Cost Model: Found an estimated cost of 3 for i
>>>
>> _______________________________________________
> llvm-commits mailing list
> llvm-commits at lists.llvm.org
> https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-commits
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20190829/5d9aa642/attachment-0001.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: smime.p7s
Type: application/pkcs7-signature
Size: 4849 bytes
Desc: S/MIME Cryptographic Signature
URL: <http://lists.llvm.org/pipermail/llvm-commits/attachments/20190829/5d9aa642/attachment-0001.bin>
More information about the llvm-commits
mailing list