
<p>FYI, three of tests have been marked as XFAIL:* locally.<br>

I will restore them when fixed.</p>

<p>Thanks for working!</p>

<div class="gmail_quote">2013/10/10 22:43 "Aaron Ballman" <<a href="mailto:aaron@aaronballman.com">aaron@aaronballman.com</a>>:<br type="attribution"><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">

Thank you for the information, and thanks to Matt for fixing the issue!<br>

<br>

~Aaron<br>

<br>

On Thu, Oct 10, 2013 at 9:41 AM, Daniel Sanders<br>

<<a href="mailto:Daniel.Sanders@imgtec.com">Daniel.Sanders@imgtec.com</a>> wrote:<br>

> Matt Arsenault's patch (<a href="http://llvm-reviews.chandlerc.com/D1568" target="_blank">http://llvm-reviews.chandlerc.com/D1568</a>) fixes all three failures. I've had a look at the assembly and I found similar code leading up to the call to __aullshr to that reported in the link. I've attached the assembly file in case you want to take a look.<br>


><br>

> From the above link:<br>

>> It turns out when loading the 64-bit value to do the shift,<br>

>> the assembly loads the 2 32-bit halves from non-consecutive<br>

>> addresses. The address the second half of the loaded uint64_t<br>

>> doesn't include the offset of the array in the struct. Instead of being<br>

>> offset + 4, it's just + 4.<br>

><br>

>> -----Original Message-----<br>

>> From: Daniel Sanders<br>

>> Sent: 09 October 2013 16:22<br>

>> To: 'NAKAMURA Takumi'<br>

>> Cc: Aaron Ballman; llvm-commits<br>

>> Subject: RE: [llvm] r191286 - [mips][msa] Added support for matching<br>

>> comparisons from normal IR (i.e. not intrinsics)<br>

>><br>

>> Good news: I've managed to reproduce the failure on VS 2012 Express<br>

>> (cl.exe version 17.00.50727.1).<br>

>><br>

>> vec_cmp.ll fails in a different way for me (it calls llvm_unreachable()), but the<br>

>> other two tests are failing in the same way as the buildbot.<br>

>><br>

>> > -----Original Message-----<br>

>> > From: NAKAMURA Takumi [mailto:<a href="mailto:geek4civic@gmail.com">geek4civic@gmail.com</a>]<br>

>> > Sent: 08 October 2013 11:26<br>

>> > To: Daniel Sanders<br>

>> > Cc: Aaron Ballman; llvm-commits<br>

>> > Subject: Re: [llvm] r191286 - [mips][msa] Added support for matching<br>

>> > comparisons from normal IR (i.e. not intrinsics)<br>

>> ><br>

>> > FYI, my builder is using Visual studio express;<br>

>> ><br>

>> > Microsoft (R) C/C++ Optimizing Compiler Version 17.00.60610.1 for x86<br>

>> > Copyright (C) Microsoft Corporation.  All rights reserved.<br>

>> ><br>

>> > I'll investigate what is happening, too. Thanks.<br>

>> ><br>

>> ><br>

>> > 2013/10/8 Daniel Sanders <<a href="mailto:Daniel.Sanders@imgtec.com">Daniel.Sanders@imgtec.com</a>>:<br>

>> > > It turns out I was using a debug build yesterday, but I don't see the<br>

>> failures<br>

>> > on a clean build with CMAKE_BUILD_TYPE=Release either.<br>

>> > ><br>

>> > >> -----Original Message-----<br>

>> > >> From: <a href="mailto:aaron.ballman@gmail.com">aaron.ballman@gmail.com</a> [mailto:<a href="mailto:aaron.ballman@gmail.com">aaron.ballman@gmail.com</a>] On<br>

>> > >> Behalf Of Aaron Ballman<br>

>> > >> Sent: 07 October 2013 18:46<br>

>> > >> To: Daniel Sanders; Takumi NAKAMURA<br>

>> > >> Cc: llvm-commits<br>

>> > >> Subject: Re: [llvm] r191286 - [mips][msa] Added support for matching<br>

>> > >> comparisons from normal IR (i.e. not intrinsics)<br>

>> > >><br>

>> > >> Another thing to note: I build Debug builds, but Chapuni's bot are<br>

>> > >> release builds.  If this is a miscompile from MSVC that needs to be<br>

>> > >> worked around, it's more likely to trigger in release builds.  Is that<br>

>> > >> what you are testing against?<br>

>> > >><br>

>> > >> ~Aaron<br>

>> > >><br>

>> > >> On Mon, Oct 7, 2013 at 12:46 PM, Aaron Ballman<br>

>> > >> <<a href="mailto:aaron@aaronballman.com">aaron@aaronballman.com</a>> wrote:<br>

>> > >> > These tests are failing for the build bot, not for me.  So they've got<br>

>> > >> > all the default options for cmake.  As for the cl version, it's both<br>

>> > >> > MSVC 10 and MSVC 11 that are failing, but perhaps Takumi can give<br>

>> > >> > further information.<br>

>> > >> ><br>

>> > >> > In my tests, I'm on Win7 x64, building a 32-bit clang with MSVC 11<br>

>> > >> > without ninja and not seeing the failure.<br>

>> > >> ><br>

>> > >> > ~Aaron<br>

>> > >> ><br>

>> > >> > On Mon, Oct 7, 2013 at 12:43 PM, Daniel Sanders<br>

>> > >> > <<a href="mailto:Daniel.Sanders@imgtec.com">Daniel.Sanders@imgtec.com</a>> wrote:<br>

>> > >> >> I haven't run the full 'ninja check' yet, but those three tests pass in<br>

>> my<br>

>> > >> MSVC build (using cmake and ninja) of r191286.<br>

>> > >> >><br>

>> > >> >> Which compiler versions are you using? I'm using cl.exe version<br>

>> > >> <a href="tel:16.00.30319.01" value="+16003031901">16.00.30319.01</a>. Also, have you set any non-default options in<br>

>> > >> CMakeCache.txt?<br>

>> > >> >><br>

>> > >> >>> -----Original Message-----<br>

>> > >> >>> From: Daniel Sanders<br>

>> > >> >>> Sent: 07 October 2013 14:27<br>

>> > >> >>> To: 'Aaron Ballman'<br>

>> > >> >>> Cc: llvm-commits<br>

>> > >> >>> Subject: RE: [llvm] r191286 - [mips][msa] Added support for<br>

>> matching<br>

>> > >> >>> comparisons from normal IR (i.e. not intrinsics)<br>

>> > >> >>><br>

>> > >> >>> I rely on the buildbot at <a href="http://lab.llvm.org" target="_blank">lab.llvm.org</a> to inform me that my changes<br>

>> > have<br>

>> > >> >>> broken builds. This failure has come from outside that buildbot so I<br>

>> > >> >>> wouldn't have known something had broken. Given that the<br>

>> > <a href="http://lab.llvm.org" target="_blank">lab.llvm.org</a><br>

>> > >> >>> builds were all ok, I don't think reverting this change (and all my<br>

>> > >> subsequent<br>

>> > >> >>> changes) is a reasonable course of action.<br>

>> > >> >>><br>

>> > >> >>> I'm setting up a MSVC host as we speak. Hopefully I should have<br>

>> > some<br>

>> > >> idea<br>

>> > >> >>> what's going on soon. I notice that Matt Arsenault has submitted a<br>

>> > patch<br>

>> > >> >>> that might be related to the solution. His patch works around an<br>

>> > MSVC<br>

>> > >> >>> miscompilation that is likely to affect<br>

>> > >> >>> CodeGen__Mips__msa__compare_float.ll.<br>

>> > >> >>><br>

>> > >> >>> > -----Original Message-----<br>

>> > >> >>> > From: <a href="mailto:aaron.ballman@gmail.com">aaron.ballman@gmail.com</a><br>

>> > [mailto:<a href="mailto:aaron.ballman@gmail.com">aaron.ballman@gmail.com</a>]<br>

>> > >> On<br>

>> > >> >>> > Behalf Of Aaron Ballman<br>

>> > >> >>> > Sent: 07 October 2013 13:52<br>

>> > >> >>> > To: Daniel Sanders<br>

>> > >> >>> > Cc: llvm-commits<br>

>> > >> >>> > Subject: Re: [llvm] r191286 - [mips][msa] Added support for<br>

>> > matching<br>

>> > >> >>> > comparisons from normal IR (i.e. not intrinsics)<br>

>> > >> >>> ><br>

>> > >> >>> > On Mon, Oct 7, 2013 at 5:11 AM, Daniel Sanders<br>

>> > >> >>> > <<a href="mailto:Daniel.Sanders@imgtec.com">Daniel.Sanders@imgtec.com</a>> wrote:<br>

>> > >> >>> > > Hi,<br>

>> > >> >>> > ><br>

>> > >> >>> > > Thanks for the report. I'll look into this but it might take a while<br>

>> to<br>

>> > fix<br>

>> > >> it<br>

>> > >> >>> > since I'll have to set up a suitable development environment to<br>

>> > >> reproduce<br>

>> > >> >>> > the problem.<br>

>> > >> >>> ><br>

>> > >> >>> > That's a bit worrisome since the build has been broken for two<br>

>> > weeks<br>

>> > >> >>> > now.  Can you please revert your changes (and r191290) until you<br>

>> > are<br>

>> > >> >>> > able to reproduce and resolve the problem?<br>

>> > >> >>> ><br>

>> > >> >>> > ~Aaron<br>

>> > >> >>> ><br>

>> > >> >>> > ><br>

>> > >> >>> > >> -----Original Message-----<br>

>> > >> >>> > >> From: <a href="mailto:aaron.ballman@gmail.com">aaron.ballman@gmail.com</a><br>

>> > >> [mailto:<a href="mailto:aaron.ballman@gmail.com">aaron.ballman@gmail.com</a>]<br>

>> > >> >>> On<br>

>> > >> >>> > >> Behalf Of Aaron Ballman<br>

>> > >> >>> > >> Sent: 06 October 2013 02:02<br>

>> > >> >>> > >> To: Daniel Sanders<br>

>> > >> >>> > >> Cc: llvm-commits<br>

>> > >> >>> > >> Subject: Re: [llvm] r191286 - [mips][msa] Added support for<br>

>> > >> matching<br>

>> > >> >>> > >> comparisons from normal IR (i.e. not intrinsics)<br>

>> > >> >>> > >><br>

>> > >> >>> > >> The MSVC builders have been broken since this commit.<br>

>> > >> Specifically:<br>

>> > >> >>> > >><br>

>> > >> >>> > >> LLVM :: CodeGen__Mips__msa__3rf_int_float.ll<br>

>> > >> >>> > >> LLVM :: CodeGen__Mips__msa__compare_float.ll<br>

>> > >> >>> > >><br>

>> > >> >>> > >> <a href="http://bb.pgr.jp/builders/ninja-clang-i686-msc17-" target="_blank">http://bb.pgr.jp/builders/ninja-clang-i686-msc17-</a><br>

>> R/builds/5000<br>

>> > >> >>> > >><br>

>> > >> >>> > >> r191290 caused LLVM :: CodeGen__Mips__msa__compare.ll<br>

>> to<br>

>> > fail<br>

>> > >> as<br>

>> > >> >>> well.<br>

>> > >> >>> > >><br>

>> > >> >>> > >> This is failing on MSVC 10 and MSVC 11.<br>

>> > >> >>> > >><br>

>> > >> >>> > >> ~Aaron<br>

>> > >> >>> > >><br>

>> > >> >>> > >> On Tue, Sep 24, 2013 at 6:46 AM, Daniel Sanders<br>

>> > >> >>> > >> <<a href="mailto:daniel.sanders@imgtec.com">daniel.sanders@imgtec.com</a>> wrote:<br>

>> > >> >>> > >> > Author: dsanders<br>

>> > >> >>> > >> > Date: Tue Sep 24 05:46:19 2013<br>

>> > >> >>> > >> > New Revision: 191286<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > URL: <a href="http://llvm.org/viewvc/llvm-" target="_blank">http://llvm.org/viewvc/llvm-</a><br>

>> > project?rev=191286&view=rev<br>

>> > >> >>> > >> > Log:<br>

>> > >> >>> > >> > [mips][msa] Added support for matching comparisons from<br>

>> > >> normal IR<br>

>> > >> >>> > (i.e.<br>

>> > >> >>> > >> not intrinsics)<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > MIPS SelectionDAG changes:<br>

>> > >> >>> > >> > * Added VCEQ, VCL[ET]_[SU] nodes to represent vector<br>

>> > >> comparisons<br>

>> > >> >>> > that<br>

>> > >> >>> > >> produce a bitmask.<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > Added:<br>

>> > >> >>> > >> >     llvm/trunk/test/CodeGen/Mips/msa/compare.ll<br>

>> > >> >>> > >> >     llvm/trunk/test/CodeGen/Mips/msa/compare_float.ll<br>

>> > >> >>> > >> > Modified:<br>

>> > >> >>> > >> >     llvm/trunk/lib/Target/Mips/MipsISelLowering.cpp<br>

>> > >> >>> > >> >     llvm/trunk/lib/Target/Mips/MipsISelLowering.h<br>

>> > >> >>> > >> >     llvm/trunk/lib/Target/Mips/MipsMSAInstrInfo.td<br>

>> > >> >>> > >> >     llvm/trunk/lib/Target/Mips/MipsSEISelLowering.cpp<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > Modified: llvm/trunk/lib/Target/Mips/MipsISelLowering.cpp<br>

>> > >> >>> > >> > URL: <a href="http://llvm.org/viewvc/llvm-" target="_blank">http://llvm.org/viewvc/llvm-</a><br>

>> > >> >>> > >><br>

>> > >> >>> ><br>

>> > >> >>><br>

>> > >><br>

>> ><br>

>> project/llvm/trunk/lib/Target/Mips/MipsISelLowering.cpp?rev=191286&r1=<br>

>> > >> >>> > 1<br>

>> > >> >>> > >> 91285&r2=191286&view=diff<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >><br>

>> > >><br>

>> ><br>

>> ==========================================================<br>

>> > >> >>> > >> ====================<br>

>> > >> >>> > >> > --- llvm/trunk/lib/Target/Mips/MipsISelLowering.cpp<br>

>> (original)<br>

>> > >> >>> > >> > +++ llvm/trunk/lib/Target/Mips/MipsISelLowering.cpp Tue<br>

>> > Sep 24<br>

>> > >> >>> > 05:46:19<br>

>> > >> >>> > >> 2013<br>

>> > >> >>> > >> > @@ -212,6 +212,11 @@ const char<br>

>> > >> *MipsTargetLowering::getTarge<br>

>> > >> >>> > >> >    case MipsISD::VANY_ZERO:         return<br>

>> > "MipsISD::VANY_ZERO";<br>

>> > >> >>> > >> >    case MipsISD::VALL_NONZERO:      return<br>

>> > >> "MipsISD::VALL_NONZERO";<br>

>> > >> >>> > >> >    case MipsISD::VANY_NONZERO:      return<br>

>> > >> >>> "MipsISD::VANY_NONZERO";<br>

>> > >> >>> > >> > +  case MipsISD::VCEQ:              return "MipsISD::VCEQ";<br>

>> > >> >>> > >> > +  case MipsISD::VCLE_S:            return "MipsISD::VCLE_S";<br>

>> > >> >>> > >> > +  case MipsISD::VCLE_U:            return "MipsISD::VCLE_U";<br>

>> > >> >>> > >> > +  case MipsISD::VCLT_S:            return "MipsISD::VCLT_S";<br>

>> > >> >>> > >> > +  case MipsISD::VCLT_U:            return "MipsISD::VCLT_U";<br>

>> > >> >>> > >> >    case MipsISD::VSPLAT:            return "MipsISD::VSPLAT";<br>

>> > >> >>> > >> >    case MipsISD::VSPLATD:           return "MipsISD::VSPLATD";<br>

>> > >> >>> > >> >    case MipsISD::VEXTRACT_SEXT_ELT: return<br>

>> > >> >>> > >> "MipsISD::VEXTRACT_SEXT_ELT";<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > Modified: llvm/trunk/lib/Target/Mips/MipsISelLowering.h<br>

>> > >> >>> > >> > URL: <a href="http://llvm.org/viewvc/llvm-" target="_blank">http://llvm.org/viewvc/llvm-</a><br>

>> > >> >>> > >><br>

>> > >> >>> ><br>

>> > >> >>><br>

>> > >><br>

>> ><br>

>> project/llvm/trunk/lib/Target/Mips/MipsISelLowering.h?rev=191286&r1=19<br>

>> > >> >>> > 1<br>

>> > >> >>> > >> 285&r2=191286&view=diff<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >><br>

>> > >><br>

>> ><br>

>> ==========================================================<br>

>> > >> >>> > >> ====================<br>

>> > >> >>> > >> > --- llvm/trunk/lib/Target/Mips/MipsISelLowering.h (original)<br>

>> > >> >>> > >> > +++ llvm/trunk/lib/Target/Mips/MipsISelLowering.h Tue Sep<br>

>> > 24<br>

>> > >> >>> 05:46:19<br>

>> > >> >>> > >> 2013<br>

>> > >> >>> > >> > @@ -153,11 +153,19 @@ namespace llvm {<br>

>> > >> >>> > >> >        SELECT_CC_DSP,<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> >        // Vector comparisons.<br>

>> > >> >>> > >> > +      // These take a vector and return a boolean.<br>

>> > >> >>> > >> >        VALL_ZERO,<br>

>> > >> >>> > >> >        VANY_ZERO,<br>

>> > >> >>> > >> >        VALL_NONZERO,<br>

>> > >> >>> > >> >        VANY_NONZERO,<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > +      // These take a vector and return a vector bitmask.<br>

>> > >> >>> > >> > +      VCEQ,<br>

>> > >> >>> > >> > +      VCLE_S,<br>

>> > >> >>> > >> > +      VCLE_U,<br>

>> > >> >>> > >> > +      VCLT_S,<br>

>> > >> >>> > >> > +      VCLT_U,<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> >        // Special case of BUILD_VECTOR where all elements are<br>

>> > the<br>

>> > >> same.<br>

>> > >> >>> > >> >        VSPLAT,<br>

>> > >> >>> > >> >        // Special case of VSPLAT where the result is v2i64, the<br>

>> > >> operand is<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > Modified: llvm/trunk/lib/Target/Mips/MipsMSAInstrInfo.td<br>

>> > >> >>> > >> > URL: <a href="http://llvm.org/viewvc/llvm-" target="_blank">http://llvm.org/viewvc/llvm-</a><br>

>> > >> >>> > >><br>

>> > >> >>> ><br>

>> > >> >>><br>

>> > >><br>

>> ><br>

>> project/llvm/trunk/lib/Target/Mips/MipsMSAInstrInfo.td?rev=191286&r1=1<br>

>> > >> >>> > >> 91285&r2=191286&view=diff<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >><br>

>> > >><br>

>> ><br>

>> ==========================================================<br>

>> > >> >>> > >> ====================<br>

>> > >> >>> > >> > --- llvm/trunk/lib/Target/Mips/MipsMSAInstrInfo.td<br>

>> (original)<br>

>> > >> >>> > >> > +++ llvm/trunk/lib/Target/Mips/MipsMSAInstrInfo.td Tue<br>

>> Sep<br>

>> > 24<br>

>> > >> >>> > 05:46:19<br>

>> > >> >>> > >> 2013<br>

>> > >> >>> > >> > @@ -13,6 +13,14 @@<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> >  def SDT_MipsSplat : SDTypeProfile<1, 1, [SDTCisVec<0>,<br>

>> > >> >>> SDTCisInt<1>]>;<br>

>> > >> >>> > >> >  def SDT_MipsVecCond : SDTypeProfile<1, 1, [SDTCisInt<0>,<br>

>> > >> >>> > >> SDTCisVec<1>]>;<br>

>> > >> >>> > >> > +def SDT_VSetCC : SDTypeProfile<1, 3, [SDTCisInt<0>,<br>

>> > >> >>> > >> > +                                      SDTCisInt<1>,<br>

>> > >> >>> > >> > +                                      SDTCisSameAs<1, 2>,<br>

>> > >> >>> > >> > +                                      SDTCisVT<3, OtherVT>]>;<br>

>> > >> >>> > >> > +def SDT_VFSetCC : SDTypeProfile<1, 3, [SDTCisInt<0>,<br>

>> > >> >>> > >> > +                                       SDTCisFP<1>,<br>

>> > >> >>> > >> > +                                       SDTCisSameAs<1, 2>,<br>

>> > >> >>> > >> > +                                       SDTCisVT<3, OtherVT>]>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> >  def MipsVAllNonZero :<br>

>> SDNode<"MipsISD::VALL_NONZERO",<br>

>> > >> >>> > >> SDT_MipsVecCond>;<br>

>> > >> >>> > >> >  def MipsVAnyNonZero :<br>

>> > SDNode<"MipsISD::VANY_NONZERO",<br>

>> > >> >>> > >> SDT_MipsVecCond>;<br>

>> > >> >>> > >> > @@ -23,6 +31,9 @@ def MipsVSplatD :<br>

>> > SDNode<"MipsISD::VSPLA<br>

>> > >> >>> > >> >  def MipsVNOR : SDNode<"MipsISD::VNOR", SDTIntBinOp,<br>

>> > >> >>> > >> >                        [SDNPCommutative, SDNPAssociative]>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > +def vsetcc : SDNode<"ISD::SETCC", SDT_VSetCC>;<br>

>> > >> >>> > >> > +def vfsetcc : SDNode<"ISD::SETCC", SDT_VFSetCC>;<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> >  def MipsVExtractSExt :<br>

>> > >> SDNode<"MipsISD::VEXTRACT_SEXT_ELT",<br>

>> > >> >>> > >> >      SDTypeProfile<1, 3, [SDTCisPtrTy<2>]>, []>;<br>

>> > >> >>> > >> >  def MipsVExtractZExt :<br>

>> > >> SDNode<"MipsISD::VEXTRACT_ZEXT_ELT",<br>

>> > >> >>> > >> > @@ -50,6 +61,68 @@ def vinsert_v8i16 : PatFrag<(ops<br>

>> node:$v<br>

>> > >> >>> > >> >  def vinsert_v4i32 : PatFrag<(ops node:$vec, node:$val,<br>

>> > >> node:$idx),<br>

>> > >> >>> > >> >      (v4i32 (vector_insert node:$vec, node:$val, node:$idx))>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > +class vfsetcc_type<ValueType ResTy, ValueType OpTy,<br>

>> > >> CondCode<br>

>> > >> >>> CC> :<br>

>> > >> >>> > >> > +  PatFrag<(ops node:$lhs, node:$rhs),<br>

>> > >> >>> > >> > +          (ResTy (vfsetcc (OpTy node:$lhs), (OpTy node:$rhs),<br>

>> > CC))>;<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +// ISD::SETFALSE cannot occur<br>

>> > >> >>> > >> > +def vfsetoeq_v4f32 : vfsetcc_type<v4i32, v4f32, SETOEQ>;<br>

>> > >> >>> > >> > +def vfsetoeq_v2f64 : vfsetcc_type<v2i64, v2f64, SETOEQ>;<br>

>> > >> >>> > >> > +def vfsetoge_v4f32 : vfsetcc_type<v4i32, v4f32, SETOGE>;<br>

>> > >> >>> > >> > +def vfsetoge_v2f64 : vfsetcc_type<v2i64, v2f64, SETOGE>;<br>

>> > >> >>> > >> > +def vfsetogt_v4f32 : vfsetcc_type<v4i32, v4f32, SETOGT>;<br>

>> > >> >>> > >> > +def vfsetogt_v2f64 : vfsetcc_type<v2i64, v2f64, SETOGT>;<br>

>> > >> >>> > >> > +def vfsetole_v4f32 : vfsetcc_type<v4i32, v4f32, SETOLE>;<br>

>> > >> >>> > >> > +def vfsetole_v2f64 : vfsetcc_type<v2i64, v2f64, SETOLE>;<br>

>> > >> >>> > >> > +def vfsetolt_v4f32 : vfsetcc_type<v4i32, v4f32, SETOLT>;<br>

>> > >> >>> > >> > +def vfsetolt_v2f64 : vfsetcc_type<v2i64, v2f64, SETOLT>;<br>

>> > >> >>> > >> > +def vfsetone_v4f32 : vfsetcc_type<v4i32, v4f32, SETONE>;<br>

>> > >> >>> > >> > +def vfsetone_v2f64 : vfsetcc_type<v2i64, v2f64, SETONE>;<br>

>> > >> >>> > >> > +def vfsetord_v4f32 : vfsetcc_type<v4i32, v4f32, SETO>;<br>

>> > >> >>> > >> > +def vfsetord_v2f64 : vfsetcc_type<v2i64, v2f64, SETO>;<br>

>> > >> >>> > >> > +def vfsetun_v4f32  : vfsetcc_type<v4i32, v4f32, SETUO>;<br>

>> > >> >>> > >> > +def vfsetun_v2f64  : vfsetcc_type<v2i64, v2f64, SETUO>;<br>

>> > >> >>> > >> > +def vfsetueq_v4f32 : vfsetcc_type<v4i32, v4f32, SETUEQ>;<br>

>> > >> >>> > >> > +def vfsetueq_v2f64 : vfsetcc_type<v2i64, v2f64, SETUEQ>;<br>

>> > >> >>> > >> > +def vfsetuge_v4f32 : vfsetcc_type<v4i32, v4f32, SETUGE>;<br>

>> > >> >>> > >> > +def vfsetuge_v2f64 : vfsetcc_type<v2i64, v2f64, SETUGE>;<br>

>> > >> >>> > >> > +def vfsetugt_v4f32 : vfsetcc_type<v4i32, v4f32, SETUGT>;<br>

>> > >> >>> > >> > +def vfsetugt_v2f64 : vfsetcc_type<v2i64, v2f64, SETUGT>;<br>

>> > >> >>> > >> > +def vfsetule_v4f32 : vfsetcc_type<v4i32, v4f32, SETULE>;<br>

>> > >> >>> > >> > +def vfsetule_v2f64 : vfsetcc_type<v2i64, v2f64, SETULE>;<br>

>> > >> >>> > >> > +def vfsetult_v4f32 : vfsetcc_type<v4i32, v4f32, SETULT>;<br>

>> > >> >>> > >> > +def vfsetult_v2f64 : vfsetcc_type<v2i64, v2f64, SETULT>;<br>

>> > >> >>> > >> > +def vfsetune_v4f32 : vfsetcc_type<v4i32, v4f32, SETUNE>;<br>

>> > >> >>> > >> > +def vfsetune_v2f64 : vfsetcc_type<v2i64, v2f64, SETUNE>;<br>

>> > >> >>> > >> > +// ISD::SETTRUE cannot occur<br>

>> > >> >>> > >> > +// ISD::SETFALSE2 cannot occur<br>

>> > >> >>> > >> > +// ISD::SETTRUE2 cannot occur<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +class vsetcc_type<ValueType ResTy, CondCode CC> :<br>

>> > >> >>> > >> > +  PatFrag<(ops node:$lhs, node:$rhs),<br>

>> > >> >>> > >> > +          (ResTy (vsetcc node:$lhs, node:$rhs, CC))>;<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +def vseteq_v16i8  : vsetcc_type<v16i8, SETEQ>;<br>

>> > >> >>> > >> > +def vseteq_v8i16  : vsetcc_type<v8i16, SETEQ>;<br>

>> > >> >>> > >> > +def vseteq_v4i32  : vsetcc_type<v4i32, SETEQ>;<br>

>> > >> >>> > >> > +def vseteq_v2i64  : vsetcc_type<v2i64, SETEQ>;<br>

>> > >> >>> > >> > +def vsetle_v16i8  : vsetcc_type<v16i8, SETLE>;<br>

>> > >> >>> > >> > +def vsetle_v8i16  : vsetcc_type<v8i16, SETLE>;<br>

>> > >> >>> > >> > +def vsetle_v4i32  : vsetcc_type<v4i32, SETLE>;<br>

>> > >> >>> > >> > +def vsetle_v2i64  : vsetcc_type<v2i64, SETLE>;<br>

>> > >> >>> > >> > +def vsetlt_v16i8  : vsetcc_type<v16i8, SETLT>;<br>

>> > >> >>> > >> > +def vsetlt_v8i16  : vsetcc_type<v8i16, SETLT>;<br>

>> > >> >>> > >> > +def vsetlt_v4i32  : vsetcc_type<v4i32, SETLT>;<br>

>> > >> >>> > >> > +def vsetlt_v2i64  : vsetcc_type<v2i64, SETLT>;<br>

>> > >> >>> > >> > +def vsetule_v16i8 : vsetcc_type<v16i8, SETULE>;<br>

>> > >> >>> > >> > +def vsetule_v8i16 : vsetcc_type<v8i16, SETULE>;<br>

>> > >> >>> > >> > +def vsetule_v4i32 : vsetcc_type<v4i32, SETULE>;<br>

>> > >> >>> > >> > +def vsetule_v2i64 : vsetcc_type<v2i64, SETULE>;<br>

>> > >> >>> > >> > +def vsetult_v16i8 : vsetcc_type<v16i8, SETULT>;<br>

>> > >> >>> > >> > +def vsetult_v8i16 : vsetcc_type<v8i16, SETULT>;<br>

>> > >> >>> > >> > +def vsetult_v4i32 : vsetcc_type<v4i32, SETULT>;<br>

>> > >> >>> > >> > +def vsetult_v2i64 : vsetcc_type<v2i64, SETULT>;<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> >  def vsplati8  : PatFrag<(ops node:$in), (v16i8 (MipsVSplat<br>

>> (i32<br>

>> > >> >>> > node:$in)))>;<br>

>> > >> >>> > >> >  def vsplati16 : PatFrag<(ops node:$in), (v8i16 (MipsVSplat<br>

>> (i32<br>

>> > >> >>> > >> node:$in)))>;<br>

>> > >> >>> > >> >  def vsplati32 : PatFrag<(ops node:$in), (v4i32 (MipsVSplat<br>

>> (i32<br>

>> > >> >>> > >> node:$in)))>;<br>

>> > >> >>> > >> > @@ -909,12 +982,14 @@ class MSA_I5_X_DESC_BASE<string<br>

>> > >> instr_as<br>

>> > >> >>> > >> >  }<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> >  class MSA_SI5_DESC_BASE<string instr_asm,<br>

>> > SDPatternOperator<br>

>> > >> >>> > OpNode,<br>

>> > >> >>> > >> > -                       RegisterClass RCWD, RegisterClass RCWS =<br>

>> RCWD,<br>

>> > >> >>> > >> > +                       SDPatternOperator SplatNode, RegisterClass<br>

>> > RCWD,<br>

>> > >> >>> > >> > +                       RegisterClass RCWS = RCWD,<br>

>> > >> >>> > >> >                         InstrItinClass itin = NoItinerary> {<br>

>> > >> >>> > >> >    dag OutOperandList = (outs RCWD:$wd);<br>

>> > >> >>> > >> >    dag InOperandList = (ins RCWS:$ws, simm5:$s5);<br>

>> > >> >>> > >> >    string AsmString = !strconcat(instr_asm, "\t$wd, $ws, $s5");<br>

>> > >> >>> > >> > -  list<dag> Pattern = [(set RCWD:$wd, (OpNode RCWS:$ws,<br>

>> > >> >>> > >> immSExt5:$s5))];<br>

>> > >> >>> > >> > +  list<dag> Pattern = [(set RCWD:$wd, (OpNode RCWS:$ws,<br>

>> > >> >>> > >> > +                                              (SplatNode immSExt5:$s5)))];<br>

>> > >> >>> > >> >    InstrItinClass Itinerary = itin;<br>

>> > >> >>> > >> >  }<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > @@ -1228,19 +1303,23 @@ class BZ_D_DESC :<br>

>> > >> >>> > >> MSA_CBRANCH_DESC_BASE<<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> >  class BZ_V_DESC : MSA_CBRANCH_DESC_BASE<"bz.v",<br>

>> > >> MSA128B>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class CEQ_B_DESC : MSA_3R_DESC_BASE<"ceq.b",<br>

>> > >> int_mips_ceq_b,<br>

>> > >> >>> > >> MSA128B>,<br>

>> > >> >>> > >> > +class CEQ_B_DESC : MSA_3R_DESC_BASE<"ceq.b",<br>

>> > >> vseteq_v16i8,<br>

>> > >> >>> > >> MSA128B>,<br>

>> > >> >>> > >> >                     IsCommutable;<br>

>> > >> >>> > >> > -class CEQ_H_DESC : MSA_3R_DESC_BASE<"ceq.h",<br>

>> > >> int_mips_ceq_h,<br>

>> > >> >>> > >> MSA128H>,<br>

>> > >> >>> > >> > +class CEQ_H_DESC : MSA_3R_DESC_BASE<"ceq.h",<br>

>> > >> vseteq_v8i16,<br>

>> > >> >>> > >> MSA128H>,<br>

>> > >> >>> > >> >                     IsCommutable;<br>

>> > >> >>> > >> > -class CEQ_W_DESC : MSA_3R_DESC_BASE<"ceq.w",<br>

>> > >> int_mips_ceq_w,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> > +class CEQ_W_DESC : MSA_3R_DESC_BASE<"ceq.w",<br>

>> > >> vseteq_v4i32,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> >                     IsCommutable;<br>

>> > >> >>> > >> > -class CEQ_D_DESC : MSA_3R_DESC_BASE<"ceq.d",<br>

>> > >> int_mips_ceq_d,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> > +class CEQ_D_DESC : MSA_3R_DESC_BASE<"ceq.d",<br>

>> > >> vseteq_v2i64,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> >                     IsCommutable;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class CEQI_B_DESC : MSA_SI5_DESC_BASE<"ceqi.b",<br>

>> > >> int_mips_ceqi_b,<br>

>> > >> >>> > >> MSA128B>;<br>

>> > >> >>> > >> > -class CEQI_H_DESC : MSA_SI5_DESC_BASE<"ceqi.h",<br>

>> > >> int_mips_ceqi_h,<br>

>> > >> >>> > >> MSA128H>;<br>

>> > >> >>> > >> > -class CEQI_W_DESC : MSA_SI5_DESC_BASE<"ceqi.w",<br>

>> > >> >>> int_mips_ceqi_w,<br>

>> > >> >>> > >> MSA128W>;<br>

>> > >> >>> > >> > -class CEQI_D_DESC : MSA_SI5_DESC_BASE<"ceqi.d",<br>

>> > >> int_mips_ceqi_d,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> > +class CEQI_B_DESC : MSA_SI5_DESC_BASE<"ceqi.b",<br>

>> > >> vseteq_v16i8,<br>

>> > >> >>> > >> vsplati8,<br>

>> > >> >>> > >> > +                                      MSA128B>;<br>

>> > >> >>> > >> > +class CEQI_H_DESC : MSA_SI5_DESC_BASE<"ceqi.h",<br>

>> > >> vseteq_v8i16,<br>

>> > >> >>> > >> vsplati16,<br>

>> > >> >>> > >> > +                                      MSA128H>;<br>

>> > >> >>> > >> > +class CEQI_W_DESC : MSA_SI5_DESC_BASE<"ceqi.w",<br>

>> > >> vseteq_v4i32,<br>

>> > >> >>> > >> vsplati32,<br>

>> > >> >>> > >> > +                                      MSA128W>;<br>

>> > >> >>> > >> > +class CEQI_D_DESC : MSA_SI5_DESC_BASE<"ceqi.d",<br>

>> > >> vseteq_v2i64,<br>

>> > >> >>> > >> vsplati64,<br>

>> > >> >>> > >> > +                                      MSA128D>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> >  class CFCMSA_DESC {<br>

>> > >> >>> > >> >    dag OutOperandList = (outs GPR32:$rd);<br>

>> > >> >>> > >> > @@ -1250,61 +1329,61 @@ class CFCMSA_DESC {<br>

>> > >> >>> > >> >    bit hasSideEffects = 1;<br>

>> > >> >>> > >> >  }<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class CLE_S_B_DESC : MSA_3R_DESC_BASE<"cle_s.b",<br>

>> > >> >>> int_mips_cle_s_b,<br>

>> > >> >>> > >> MSA128B>;<br>

>> > >> >>> > >> > -class CLE_S_H_DESC : MSA_3R_DESC_BASE<"cle_s.h",<br>

>> > >> >>> int_mips_cle_s_h,<br>

>> > >> >>> > >> MSA128H>;<br>

>> > >> >>> > >> > -class CLE_S_W_DESC : MSA_3R_DESC_BASE<"cle_s.w",<br>

>> > >> >>> > >> int_mips_cle_s_w, MSA128W>;<br>

>> > >> >>> > >> > -class CLE_S_D_DESC : MSA_3R_DESC_BASE<"cle_s.d",<br>

>> > >> >>> int_mips_cle_s_d,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> > -<br>

>> > >> >>> > >> > -class CLE_U_B_DESC : MSA_3R_DESC_BASE<"cle_u.b",<br>

>> > >> >>> > int_mips_cle_u_b,<br>

>> > >> >>> > >> MSA128B>;<br>

>> > >> >>> > >> > -class CLE_U_H_DESC : MSA_3R_DESC_BASE<"cle_u.h",<br>

>> > >> >>> > int_mips_cle_u_h,<br>

>> > >> >>> > >> MSA128H>;<br>

>> > >> >>> > >> > -class CLE_U_W_DESC : MSA_3R_DESC_BASE<"cle_u.w",<br>

>> > >> >>> > >> int_mips_cle_u_w, MSA128W>;<br>

>> > >> >>> > >> > -class CLE_U_D_DESC : MSA_3R_DESC_BASE<"cle_u.d",<br>

>> > >> >>> > int_mips_cle_u_d,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> > +class CLE_S_B_DESC : MSA_3R_DESC_BASE<"cle_s.b",<br>

>> > >> vsetle_v16i8,<br>

>> > >> >>> > >> MSA128B>;<br>

>> > >> >>> > >> > +class CLE_S_H_DESC : MSA_3R_DESC_BASE<"cle_s.h",<br>

>> > >> vsetle_v8i16,<br>

>> > >> >>> > >> MSA128H>;<br>

>> > >> >>> > >> > +class CLE_S_W_DESC : MSA_3R_DESC_BASE<"cle_s.w",<br>

>> > >> vsetle_v4i32,<br>

>> > >> >>> > >> MSA128W>;<br>

>> > >> >>> > >> > +class CLE_S_D_DESC : MSA_3R_DESC_BASE<"cle_s.d",<br>

>> > >> vsetle_v2i64,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +class CLE_U_B_DESC : MSA_3R_DESC_BASE<"cle_u.b",<br>

>> > >> vsetule_v16i8,<br>

>> > >> >>> > >> MSA128B>;<br>

>> > >> >>> > >> > +class CLE_U_H_DESC : MSA_3R_DESC_BASE<"cle_u.h",<br>

>> > >> vsetule_v8i16,<br>

>> > >> >>> > >> MSA128H>;<br>

>> > >> >>> > >> > +class CLE_U_W_DESC : MSA_3R_DESC_BASE<"cle_u.w",<br>

>> > >> vsetule_v4i32,<br>

>> > >> >>> > >> MSA128W>;<br>

>> > >> >>> > >> > +class CLE_U_D_DESC : MSA_3R_DESC_BASE<"cle_u.d",<br>

>> > >> vsetule_v2i64,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class CLEI_S_B_DESC : MSA_SI5_DESC_BASE<"clei_s.b",<br>

>> > >> >>> > >> int_mips_clei_s_b,<br>

>> > >> >>> > >> > +class CLEI_S_B_DESC : MSA_SI5_DESC_BASE<"clei_s.b",<br>

>> > >> vsetle_v16i8,<br>

>> > >> >>> > >> vsplati8,<br>

>> > >> >>> > >> >                                          MSA128B>;<br>

>> > >> >>> > >> > -class CLEI_S_H_DESC : MSA_SI5_DESC_BASE<"clei_s.h",<br>

>> > >> >>> > >> int_mips_clei_s_h,<br>

>> > >> >>> > >> > +class CLEI_S_H_DESC : MSA_SI5_DESC_BASE<"clei_s.h",<br>

>> > >> vsetle_v8i16,<br>

>> > >> >>> > >> vsplati16,<br>

>> > >> >>> > >> >                                          MSA128H>;<br>

>> > >> >>> > >> > -class CLEI_S_W_DESC : MSA_SI5_DESC_BASE<"clei_s.w",<br>

>> > >> >>> > >> int_mips_clei_s_w,<br>

>> > >> >>> > >> > +class CLEI_S_W_DESC : MSA_SI5_DESC_BASE<"clei_s.w",<br>

>> > >> vsetle_v4i32,<br>

>> > >> >>> > >> vsplati32,<br>

>> > >> >>> > >> >                                          MSA128W>;<br>

>> > >> >>> > >> > -class CLEI_S_D_DESC : MSA_SI5_DESC_BASE<"clei_s.d",<br>

>> > >> >>> > >> int_mips_clei_s_d,<br>

>> > >> >>> > >> > +class CLEI_S_D_DESC : MSA_SI5_DESC_BASE<"clei_s.d",<br>

>> > >> vsetle_v2i64,<br>

>> > >> >>> > >> vsplati64,<br>

>> > >> >>> > >> >                                          MSA128D>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class CLEI_U_B_DESC : MSA_SI5_DESC_BASE<"clei_u.b",<br>

>> > >> >>> > >> int_mips_clei_u_b,<br>

>> > >> >>> > >> > -                                        MSA128B>;<br>

>> > >> >>> > >> > -class CLEI_U_H_DESC : MSA_SI5_DESC_BASE<"clei_u.h",<br>

>> > >> >>> > >> int_mips_clei_u_h,<br>

>> > >> >>> > >> > -                                        MSA128H>;<br>

>> > >> >>> > >> > -class CLEI_U_W_DESC : MSA_SI5_DESC_BASE<"clei_u.w",<br>

>> > >> >>> > >> int_mips_clei_u_w,<br>

>> > >> >>> > >> > -                                        MSA128W>;<br>

>> > >> >>> > >> > -class CLEI_U_D_DESC : MSA_SI5_DESC_BASE<"clei_u.d",<br>

>> > >> >>> > >> int_mips_clei_u_d,<br>

>> > >> >>> > >> > -                                        MSA128D>;<br>

>> > >> >>> > >> > +class CLEI_U_B_DESC : MSA_I5_DESC_BASE<"clei_u.b",<br>

>> > >> vsetule_v16i8,<br>

>> > >> >>> > >> vsplati8,<br>

>> > >> >>> > >> > +                                       MSA128B>;<br>

>> > >> >>> > >> > +class CLEI_U_H_DESC : MSA_I5_DESC_BASE<"clei_u.h",<br>

>> > >> vsetule_v8i16,<br>

>> > >> >>> > >> vsplati16,<br>

>> > >> >>> > >> > +                                       MSA128H>;<br>

>> > >> >>> > >> > +class CLEI_U_W_DESC : MSA_I5_DESC_BASE<"clei_u.w",<br>

>> > >> >>> vsetule_v4i32,<br>

>> > >> >>> > >> vsplati32,<br>

>> > >> >>> > >> > +                                       MSA128W>;<br>

>> > >> >>> > >> > +class CLEI_U_D_DESC : MSA_I5_DESC_BASE<"clei_u.d",<br>

>> > >> vsetule_v2i64,<br>

>> > >> >>> > >> vsplati64,<br>

>> > >> >>> > >> > +                                       MSA128D>;<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +class CLT_S_B_DESC : MSA_3R_DESC_BASE<"clt_s.b",<br>

>> > >> vsetlt_v16i8,<br>

>> > >> >>> > >> MSA128B>;<br>

>> > >> >>> > >> > +class CLT_S_H_DESC : MSA_3R_DESC_BASE<"clt_s.h",<br>

>> > >> vsetlt_v8i16,<br>

>> > >> >>> > >> MSA128H>;<br>

>> > >> >>> > >> > +class CLT_S_W_DESC : MSA_3R_DESC_BASE<"clt_s.w",<br>

>> > >> vsetlt_v4i32,<br>

>> > >> >>> > >> MSA128W>;<br>

>> > >> >>> > >> > +class CLT_S_D_DESC : MSA_3R_DESC_BASE<"clt_s.d",<br>

>> > >> vsetlt_v2i64,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +class CLT_U_B_DESC : MSA_3R_DESC_BASE<"clt_u.b",<br>

>> > >> vsetult_v16i8,<br>

>> > >> >>> > >> MSA128B>;<br>

>> > >> >>> > >> > +class CLT_U_H_DESC : MSA_3R_DESC_BASE<"clt_u.h",<br>

>> > >> vsetult_v8i16,<br>

>> > >> >>> > >> MSA128H>;<br>

>> > >> >>> > >> > +class CLT_U_W_DESC : MSA_3R_DESC_BASE<"clt_u.w",<br>

>> > >> vsetult_v4i32,<br>

>> > >> >>> > >> MSA128W>;<br>

>> > >> >>> > >> > +class CLT_U_D_DESC : MSA_3R_DESC_BASE<"clt_u.d",<br>

>> > >> vsetult_v2i64,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class CLT_S_B_DESC : MSA_3R_DESC_BASE<"clt_s.b",<br>

>> > >> >>> int_mips_clt_s_b,<br>

>> > >> >>> > >> MSA128B>;<br>

>> > >> >>> > >> > -class CLT_S_H_DESC : MSA_3R_DESC_BASE<"clt_s.h",<br>

>> > >> >>> int_mips_clt_s_h,<br>

>> > >> >>> > >> MSA128H>;<br>

>> > >> >>> > >> > -class CLT_S_W_DESC : MSA_3R_DESC_BASE<"clt_s.w",<br>

>> > >> >>> > int_mips_clt_s_w,<br>

>> > >> >>> > >> MSA128W>;<br>

>> > >> >>> > >> > -class CLT_S_D_DESC : MSA_3R_DESC_BASE<"clt_s.d",<br>

>> > >> >>> int_mips_clt_s_d,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> > -<br>

>> > >> >>> > >> > -class CLT_U_B_DESC : MSA_3R_DESC_BASE<"clt_u.b",<br>

>> > >> >>> int_mips_clt_u_b,<br>

>> > >> >>> > >> MSA128B>;<br>

>> > >> >>> > >> > -class CLT_U_H_DESC : MSA_3R_DESC_BASE<"clt_u.h",<br>

>> > >> >>> int_mips_clt_u_h,<br>

>> > >> >>> > >> MSA128H>;<br>

>> > >> >>> > >> > -class CLT_U_W_DESC : MSA_3R_DESC_BASE<"clt_u.w",<br>

>> > >> >>> > >> int_mips_clt_u_w, MSA128W>;<br>

>> > >> >>> > >> > -class CLT_U_D_DESC : MSA_3R_DESC_BASE<"clt_u.d",<br>

>> > >> >>> int_mips_clt_u_d,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> > -<br>

>> > >> >>> > >> > -class CLTI_S_B_DESC : MSA_SI5_DESC_BASE<"clti_s.b",<br>

>> > >> >>> > int_mips_clti_s_b,<br>

>> > >> >>> > >> > +class CLTI_S_B_DESC : MSA_SI5_DESC_BASE<"clti_s.b",<br>

>> > >> vsetlt_v16i8,<br>

>> > >> >>> > >> vsplati8,<br>

>> > >> >>> > >> >                                          MSA128B>;<br>

>> > >> >>> > >> > -class CLTI_S_H_DESC : MSA_SI5_DESC_BASE<"clti_s.h",<br>

>> > >> >>> > int_mips_clti_s_h,<br>

>> > >> >>> > >> > +class CLTI_S_H_DESC : MSA_SI5_DESC_BASE<"clti_s.h",<br>

>> > >> vsetlt_v8i16,<br>

>> > >> >>> > >> vsplati16,<br>

>> > >> >>> > >> >                                          MSA128H>;<br>

>> > >> >>> > >> > -class CLTI_S_W_DESC : MSA_SI5_DESC_BASE<"clti_s.w",<br>

>> > >> >>> > >> int_mips_clti_s_w,<br>

>> > >> >>> > >> > +class CLTI_S_W_DESC : MSA_SI5_DESC_BASE<"clti_s.w",<br>

>> > >> vsetlt_v4i32,<br>

>> > >> >>> > >> vsplati32,<br>

>> > >> >>> > >> >                                          MSA128W>;<br>

>> > >> >>> > >> > -class CLTI_S_D_DESC : MSA_SI5_DESC_BASE<"clti_s.d",<br>

>> > >> >>> > int_mips_clti_s_d,<br>

>> > >> >>> > >> > +class CLTI_S_D_DESC : MSA_SI5_DESC_BASE<"clti_s.d",<br>

>> > >> vsetlt_v2i64,<br>

>> > >> >>> > >> vsplati64,<br>

>> > >> >>> > >> >                                          MSA128D>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class CLTI_U_B_DESC : MSA_SI5_DESC_BASE<"clti_u.b",<br>

>> > >> >>> > >> int_mips_clti_u_b,<br>

>> > >> >>> > >> > -                                        MSA128B>;<br>

>> > >> >>> > >> > -class CLTI_U_H_DESC : MSA_SI5_DESC_BASE<"clti_u.h",<br>

>> > >> >>> > >> int_mips_clti_u_h,<br>

>> > >> >>> > >> > -                                        MSA128H>;<br>

>> > >> >>> > >> > -class CLTI_U_W_DESC : MSA_SI5_DESC_BASE<"clti_u.w",<br>

>> > >> >>> > >> int_mips_clti_u_w,<br>

>> > >> >>> > >> > -                                        MSA128W>;<br>

>> > >> >>> > >> > -class CLTI_U_D_DESC : MSA_SI5_DESC_BASE<"clti_u.d",<br>

>> > >> >>> > >> int_mips_clti_u_d,<br>

>> > >> >>> > >> > -                                        MSA128D>;<br>

>> > >> >>> > >> > +class CLTI_U_B_DESC : MSA_I5_DESC_BASE<"clti_u.b",<br>

>> > >> vsetult_v16i8,<br>

>> > >> >>> > >> vsplati8,<br>

>> > >> >>> > >> > +                                       MSA128B>;<br>

>> > >> >>> > >> > +class CLTI_U_H_DESC : MSA_I5_DESC_BASE<"clti_u.h",<br>

>> > >> vsetult_v8i16,<br>

>> > >> >>> > >> vsplati16,<br>

>> > >> >>> > >> > +                                       MSA128H>;<br>

>> > >> >>> > >> > +class CLTI_U_W_DESC : MSA_I5_DESC_BASE<"clti_u.w",<br>

>> > >> vsetult_v4i32,<br>

>> > >> >>> > >> vsplati32,<br>

>> > >> >>> > >> > +                                       MSA128W>;<br>

>> > >> >>> > >> > +class CLTI_U_D_DESC : MSA_I5_DESC_BASE<"clti_u.d",<br>

>> > >> vsetult_v2i64,<br>

>> > >> >>> > >> vsplati64,<br>

>> > >> >>> > >> > +                                       MSA128D>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> >  class COPY_S_B_DESC :<br>

>> MSA_COPY_DESC_BASE<"copy_s.b",<br>

>> > >> >>> > >> vextract_sext_i8,  v16i8,<br>

>> > >> >>> > >> >                                           GPR32, MSA128B>;<br>

>> > >> >>> > >> > @@ -1394,9 +1473,9 @@ class FCAF_W_DESC :<br>

>> > >> >>> MSA_3RF_DESC_BASE<"f<br>

>> > >> >>> > >> >  class FCAF_D_DESC : MSA_3RF_DESC_BASE<"fcaf.d",<br>

>> > >> int_mips_fcaf_d,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> >                      IsCommutable;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class FCEQ_W_DESC : MSA_3RF_DESC_BASE<"fceq.w",<br>

>> > >> >>> > int_mips_fceq_w,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> > +class FCEQ_W_DESC : MSA_3RF_DESC_BASE<"fceq.w",<br>

>> > >> >>> vfsetoeq_v4f32,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> >                      IsCommutable;<br>

>> > >> >>> > >> > -class FCEQ_D_DESC : MSA_3RF_DESC_BASE<"fceq.d",<br>

>> > >> >>> int_mips_fceq_d,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> > +class FCEQ_D_DESC : MSA_3RF_DESC_BASE<"fceq.d",<br>

>> > >> vfsetoeq_v2f64,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> >                      IsCommutable;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> >  class FCLASS_W_DESC : MSA_2RF_DESC_BASE<"fclass.w",<br>

>> > >> >>> > >> int_mips_fclass_w,<br>

>> > >> >>> > >> > @@ -1404,45 +1483,45 @@ class FCLASS_W_DESC :<br>

>> > >> >>> > MSA_2RF_DESC_BASE<<br>

>> > >> >>> > >> >  class FCLASS_D_DESC : MSA_2RF_DESC_BASE<"fclass.d",<br>

>> > >> >>> > >> int_mips_fclass_d,<br>

>> > >> >>> > >> >                                          MSA128D>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class FCLE_W_DESC : MSA_3RF_DESC_BASE<"fcle.w",<br>

>> > >> >>> int_mips_fcle_w,<br>

>> > >> >>> > >> MSA128W>;<br>

>> > >> >>> > >> > -class FCLE_D_DESC : MSA_3RF_DESC_BASE<"fcle.d",<br>

>> > >> int_mips_fcle_d,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> > +class FCLE_W_DESC : MSA_3RF_DESC_BASE<"fcle.w",<br>

>> > >> vfsetole_v4f32,<br>

>> > >> >>> > >> MSA128W>;<br>

>> > >> >>> > >> > +class FCLE_D_DESC : MSA_3RF_DESC_BASE<"fcle.d",<br>

>> > >> vfsetole_v2f64,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class FCLT_W_DESC : MSA_3RF_DESC_BASE<"fclt.w",<br>

>> > >> int_mips_fclt_w,<br>

>> > >> >>> > >> MSA128W>;<br>

>> > >> >>> > >> > -class FCLT_D_DESC : MSA_3RF_DESC_BASE<"fclt.d",<br>

>> > >> int_mips_fclt_d,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> > +class FCLT_W_DESC : MSA_3RF_DESC_BASE<"fclt.w",<br>

>> > >> vfsetolt_v4f32,<br>

>> > >> >>> > >> MSA128W>;<br>

>> > >> >>> > >> > +class FCLT_D_DESC : MSA_3RF_DESC_BASE<"fclt.d",<br>

>> > >> vfsetolt_v2f64,<br>

>> > >> >>> > >> MSA128D>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class FCNE_W_DESC : MSA_3RF_DESC_BASE<"fcne.w",<br>

>> > >> >>> > int_mips_fcne_w,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> > +class FCNE_W_DESC : MSA_3RF_DESC_BASE<"fcne.w",<br>

>> > >> >>> vfsetone_v4f32,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> >                      IsCommutable;<br>

>> > >> >>> > >> > -class FCNE_D_DESC : MSA_3RF_DESC_BASE<"fcne.d",<br>

>> > >> >>> int_mips_fcne_d,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> > +class FCNE_D_DESC : MSA_3RF_DESC_BASE<"fcne.d",<br>

>> > >> vfsetone_v2f64,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> >                      IsCommutable;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class FCOR_W_DESC : MSA_3RF_DESC_BASE<"fcor.w",<br>

>> > >> >>> int_mips_fcor_w,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> > +class FCOR_W_DESC : MSA_3RF_DESC_BASE<"fcor.w",<br>

>> > >> >>> vfsetord_v4f32,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> >                      IsCommutable;<br>

>> > >> >>> > >> > -class FCOR_D_DESC : MSA_3RF_DESC_BASE<"fcor.d",<br>

>> > >> int_mips_fcor_d,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> > +class FCOR_D_DESC : MSA_3RF_DESC_BASE<"fcor.d",<br>

>> > >> vfsetord_v2f64,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> >                      IsCommutable;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class FCUEQ_W_DESC : MSA_3RF_DESC_BASE<"fcueq.w",<br>

>> > >> >>> > >> int_mips_fcueq_w, MSA128W>,<br>

>> > >> >>> > >> > +class FCUEQ_W_DESC : MSA_3RF_DESC_BASE<"fcueq.w",<br>

>> > >> >>> > >> vfsetueq_v4f32, MSA128W>,<br>

>> > >> >>> > >> >                       IsCommutable;<br>

>> > >> >>> > >> > -class FCUEQ_D_DESC : MSA_3RF_DESC_BASE<"fcueq.d",<br>

>> > >> >>> > >> int_mips_fcueq_d, MSA128D>,<br>

>> > >> >>> > >> > +class FCUEQ_D_DESC : MSA_3RF_DESC_BASE<"fcueq.d",<br>

>> > >> >>> > vfsetueq_v2f64,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> >                       IsCommutable;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class FCULE_W_DESC : MSA_3RF_DESC_BASE<"fcule.w",<br>

>> > >> >>> > >> int_mips_fcule_w, MSA128W>,<br>

>> > >> >>> > >> > +class FCULE_W_DESC : MSA_3RF_DESC_BASE<"fcule.w",<br>

>> > >> >>> > vfsetule_v4f32,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> >                       IsCommutable;<br>

>> > >> >>> > >> > -class FCULE_D_DESC : MSA_3RF_DESC_BASE<"fcule.d",<br>

>> > >> >>> > int_mips_fcule_d,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> > +class FCULE_D_DESC : MSA_3RF_DESC_BASE<"fcule.d",<br>

>> > >> >>> vfsetule_v2f64,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> >                       IsCommutable;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class FCULT_W_DESC : MSA_3RF_DESC_BASE<"fcult.w",<br>

>> > >> >>> > >> int_mips_fcult_w, MSA128W>,<br>

>> > >> >>> > >> > +class FCULT_W_DESC : MSA_3RF_DESC_BASE<"fcult.w",<br>

>> > >> >>> vfsetult_v4f32,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> >                       IsCommutable;<br>

>> > >> >>> > >> > -class FCULT_D_DESC : MSA_3RF_DESC_BASE<"fcult.d",<br>

>> > >> >>> > int_mips_fcult_d,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> > +class FCULT_D_DESC : MSA_3RF_DESC_BASE<"fcult.d",<br>

>> > >> vfsetult_v2f64,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> >                       IsCommutable;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class FCUN_W_DESC : MSA_3RF_DESC_BASE<"fcun.w",<br>

>> > >> >>> > int_mips_fcun_w,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> > +class FCUN_W_DESC : MSA_3RF_DESC_BASE<"fcun.w",<br>

>> > >> vfsetun_v4f32,<br>

>> > >> >>> > >> MSA128W>,<br>

>> > >> >>> > >> >                      IsCommutable;<br>

>> > >> >>> > >> > -class FCUN_D_DESC : MSA_3RF_DESC_BASE<"fcun.d",<br>

>> > >> >>> int_mips_fcun_d,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> > +class FCUN_D_DESC : MSA_3RF_DESC_BASE<"fcun.d",<br>

>> > >> vfsetun_v2f64,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> >                      IsCommutable;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > -class FCUNE_W_DESC : MSA_3RF_DESC_BASE<"fcune.w",<br>

>> > >> >>> > >> int_mips_fcune_w, MSA128W>,<br>

>> > >> >>> > >> > +class FCUNE_W_DESC : MSA_3RF_DESC_BASE<"fcune.w",<br>

>> > >> >>> > >> vfsetune_v4f32, MSA128W>,<br>

>> > >> >>> > >> >                       IsCommutable;<br>

>> > >> >>> > >> > -class FCUNE_D_DESC : MSA_3RF_DESC_BASE<"fcune.d",<br>

>> > >> >>> > >> int_mips_fcune_d, MSA128D>,<br>

>> > >> >>> > >> > +class FCUNE_D_DESC : MSA_3RF_DESC_BASE<"fcune.d",<br>

>> > >> >>> > vfsetune_v2f64,<br>

>> > >> >>> > >> MSA128D>,<br>

>> > >> >>> > >> >                       IsCommutable;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> >  class FDIV_W_DESC : MSA_3RF_DESC_BASE<"fdiv.w", fdiv,<br>

>> > >> >>> MSA128W>;<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > Modified:<br>

>> llvm/trunk/lib/Target/Mips/MipsSEISelLowering.cpp<br>

>> > >> >>> > >> > URL: <a href="http://llvm.org/viewvc/llvm-" target="_blank">http://llvm.org/viewvc/llvm-</a><br>

>> > >> >>> > >><br>

>> > >> >>> ><br>

>> > >> >>><br>

>> > >><br>

>> ><br>

>> project/llvm/trunk/lib/Target/Mips/MipsSEISelLowering.cpp?rev=191286&r<br>

>> > >> >>> > 1<br>

>> > >> >>> > >> =191285&r2=191286&view=diff<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >><br>

>> > >><br>

>> ><br>

>> ==========================================================<br>

>> > >> >>> > >> ====================<br>

>> > >> >>> > >> > --- llvm/trunk/lib/Target/Mips/MipsSEISelLowering.cpp<br>

>> > (original)<br>

>> > >> >>> > >> > +++ llvm/trunk/lib/Target/Mips/MipsSEISelLowering.cpp Tue<br>

>> > Sep<br>

>> > >> 24<br>

>> > >> >>> > >> 05:46:19 2013<br>

>> > >> >>> > >> > @@ -180,6 +180,13 @@<br>

>> > addMSAIntType(MVT::SimpleValueType<br>

>> > >> Ty, c<br>

>> > >> >>> > >> >    setOperationAction(ISD::SUB, Ty, Legal);<br>

>> > >> >>> > >> >    setOperationAction(ISD::UDIV, Ty, Legal);<br>

>> > >> >>> > >> >    setOperationAction(ISD::XOR, Ty, Legal);<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  setOperationAction(ISD::SETCC, Ty, Legal);<br>

>> > >> >>> > >> > +  setCondCodeAction(ISD::SETNE, Ty, Expand);<br>

>> > >> >>> > >> > +  setCondCodeAction(ISD::SETGE, Ty, Expand);<br>

>> > >> >>> > >> > +  setCondCodeAction(ISD::SETGT, Ty, Expand);<br>

>> > >> >>> > >> > +  setCondCodeAction(ISD::SETUGE, Ty, Expand);<br>

>> > >> >>> > >> > +  setCondCodeAction(ISD::SETUGT, Ty, Expand);<br>

>> > >> >>> > >> >  }<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> >  // Enable MSA support for the given floating-point type and<br>

>> > >> Register<br>

>> > >> >>> > class.<br>

>> > >> >>> > >> > @@ -204,6 +211,14 @@<br>

>> > >> addMSAFloatType(MVT::SimpleValueType Ty,<br>

>> > >> >>> > >> >      setOperationAction(ISD::FRINT, Ty, Legal);<br>

>> > >> >>> > >> >      setOperationAction(ISD::FSQRT, Ty, Legal);<br>

>> > >> >>> > >> >      setOperationAction(ISD::FSUB,  Ty, Legal);<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +    setOperationAction(ISD::SETCC, Ty, Legal);<br>

>> > >> >>> > >> > +    setCondCodeAction(ISD::SETOGE, Ty, Expand);<br>

>> > >> >>> > >> > +    setCondCodeAction(ISD::SETOGT, Ty, Expand);<br>

>> > >> >>> > >> > +    setCondCodeAction(ISD::SETUGE, Ty, Expand);<br>

>> > >> >>> > >> > +    setCondCodeAction(ISD::SETUGT, Ty, Expand);<br>

>> > >> >>> > >> > +    setCondCodeAction(ISD::SETGE,  Ty, Expand);<br>

>> > >> >>> > >> > +    setCondCodeAction(ISD::SETGT,  Ty, Expand);<br>

>> > >> >>> > >> >    }<br>

>> > >> >>> > >> >  }<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > @@ -1109,6 +1124,66 @@ SDValue<br>

>> > >> MipsSETargetLowering::lowerINTRI<br>

>> > >> >>> > >> >      return lowerMSABranchIntr(Op, DAG,<br>

>> > MipsISD::VALL_ZERO);<br>

>> > >> >>> > >> >    case Intrinsic::mips_bz_v:<br>

>> > >> >>> > >> >      return lowerMSABranchIntr(Op, DAG,<br>

>> > MipsISD::VANY_ZERO);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_ceq_b:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_ceq_h:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_ceq_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_ceq_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETEQ);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_ceqi_b:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_ceqi_h:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_ceqi_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_ceqi_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        lowerMSASplatImm(Op, 2, DAG), ISD::SETEQ);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_cle_s_b:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_cle_s_h:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_cle_s_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_cle_s_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETLE);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clei_s_b:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clei_s_h:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clei_s_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clei_s_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        lowerMSASplatImm(Op, 2, DAG), ISD::SETLE);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_cle_u_b:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_cle_u_h:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_cle_u_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_cle_u_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETULE);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clei_u_b:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clei_u_h:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clei_u_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clei_u_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        lowerMSASplatImm(Op, 2, DAG), ISD::SETULE);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clt_s_b:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clt_s_h:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clt_s_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clt_s_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETLT);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clti_s_b:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clti_s_h:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clti_s_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clti_s_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        lowerMSASplatImm(Op, 2, DAG), ISD::SETLT);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clt_u_b:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clt_u_h:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clt_u_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clt_u_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETULT);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clti_u_b:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clti_u_h:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clti_u_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_clti_u_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        lowerMSASplatImm(Op, 2, DAG), ISD::SETULT);<br>

>> > >> >>> > >> >    case Intrinsic::mips_copy_s_b:<br>

>> > >> >>> > >> >    case Intrinsic::mips_copy_s_h:<br>

>> > >> >>> > >> >    case Intrinsic::mips_copy_s_w:<br>

>> > >> >>> > >> > @@ -1130,6 +1205,47 @@ SDValue<br>

>> > >> MipsSETargetLowering::lowerINTRI<br>

>> > >> >>> > >> >    case Intrinsic::mips_fadd_w:<br>

>> > >> >>> > >> >    case Intrinsic::mips_fadd_d:<br>

>> > >> >>> > >> >      return lowerMSABinaryIntr(Op, DAG, ISD::FADD);<br>

>> > >> >>> > >> > +  // Don't lower mips_fcaf_[wd] since LLVM folds SETFALSE<br>

>> > >> condcodes<br>

>> > >> >>> > >> away<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fceq_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fceq_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETOEQ);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcle_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcle_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETOLE);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fclt_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fclt_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETOLT);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcne_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcne_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETONE);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcor_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcor_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETO);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcueq_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcueq_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETUEQ);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcule_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcule_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETULE);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcult_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcult_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETULT);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcun_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcun_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETUO);<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcune_w:<br>

>> > >> >>> > >> > +  case Intrinsic::mips_fcune_d:<br>

>> > >> >>> > >> > +    return DAG.getSetCC(SDLoc(Op), Op->getValueType(0),<br>

>> > Op-<br>

>> > >> >>> > >> >getOperand(1),<br>

>> > >> >>> > >> > +                        Op->getOperand(2), ISD::SETUNE);<br>

>> > >> >>> > >> >    case Intrinsic::mips_fdiv_w:<br>

>> > >> >>> > >> >    case Intrinsic::mips_fdiv_d:<br>

>> > >> >>> > >> >      return lowerMSABinaryIntr(Op, DAG, ISD::FDIV);<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > Added: llvm/trunk/test/CodeGen/Mips/msa/compare.ll<br>

>> > >> >>> > >> > URL: <a href="http://llvm.org/viewvc/llvm-" target="_blank">http://llvm.org/viewvc/llvm-</a><br>

>> > >> >>> > >><br>

>> > >> >>> ><br>

>> > >> >>><br>

>> > >><br>

>> ><br>

>> project/llvm/trunk/test/CodeGen/Mips/msa/compare.ll?rev=191286&view<br>

>> > >> >>> > =<br>

>> > >> >>> > >> auto<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >><br>

>> > >><br>

>> ><br>

>> ==========================================================<br>

>> > >> >>> > >> ====================<br>

>> > >> >>> > >> > --- llvm/trunk/test/CodeGen/Mips/msa/compare.ll (added)<br>

>> > >> >>> > >> > +++ llvm/trunk/test/CodeGen/Mips/msa/compare.ll Tue<br>

>> Sep<br>

>> > 24<br>

>> > >> >>> > 05:46:19<br>

>> > >> >>> > >> 2013<br>

>> > >> >>> > >> > @@ -0,0 +1,641 @@<br>

>> > >> >>> > >> > +; RUN: llc -march=mips -mattr=+msa < %s | FileCheck %s<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ceq_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16 x<br>

>> > i8>*<br>

>> > >> %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ceq_v16i8:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <16 x i8>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <16 x i8>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp eq <16 x i8> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <16 x i1> %3 to <16 x i8><br>

>> > >> >>> > >> > +  ; CHECK-DAG: ceq.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <16 x i8> %4, <16 x i8>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.b [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ceq_v16i8<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ceq_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x<br>

>> > i16>*<br>

>> > >> %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ceq_v8i16:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <8 x i16>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <8 x i16>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp eq <8 x i16> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <8 x i1> %3 to <8 x i16><br>

>> > >> >>> > >> > +  ; CHECK-DAG: ceq.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <8 x i16> %4, <8 x i16>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.h [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ceq_v8i16<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ceq_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x<br>

>> > i32>*<br>

>> > >> %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ceq_v4i32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x i32>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x i32>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp eq <4 x i32> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: ceq.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ceq_v4i32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ceq_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x<br>

>> > i64>*<br>

>> > >> %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ceq_v2i64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x i64>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x i64>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp eq <2 x i64> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: ceq.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ceq_v2i64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @cle_s_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16<br>

>> x<br>

>> > >> i8>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: cle_s_v16i8:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <16 x i8>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <16 x i8>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp sle <16 x i8> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <16 x i1> %3 to <16 x i8><br>

>> > >> >>> > >> > +  ; CHECK-DAG: cle_s.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <16 x i8> %4, <16 x i8>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.b [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size cle_s_v16i8<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @cle_s_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x<br>

>> > >> i16>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: cle_s_v8i16:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <8 x i16>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <8 x i16>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp sle <8 x i16> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <8 x i1> %3 to <8 x i16><br>

>> > >> >>> > >> > +  ; CHECK-DAG: cle_s.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <8 x i16> %4, <8 x i16>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.h [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size cle_s_v8i16<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @cle_s_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x<br>

>> > >> i32>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: cle_s_v4i32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x i32>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x i32>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp sle <4 x i32> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: cle_s.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size cle_s_v4i32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @cle_s_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x<br>

>> > >> i64>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: cle_s_v2i64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x i64>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x i64>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp sle <2 x i64> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: cle_s.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size cle_s_v2i64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @cle_u_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16<br>

>> x<br>

>> > >> i8>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: cle_u_v16i8:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <16 x i8>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <16 x i8>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp ule <16 x i8> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <16 x i1> %3 to <16 x i8><br>

>> > >> >>> > >> > +  ; CHECK-DAG: cle_u.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <16 x i8> %4, <16 x i8>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.b [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size cle_u_v16i8<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @cle_u_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x<br>

>> > >> i16>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: cle_u_v8i16:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <8 x i16>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <8 x i16>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp ule <8 x i16> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <8 x i1> %3 to <8 x i16><br>

>> > >> >>> > >> > +  ; CHECK-DAG: cle_u.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <8 x i16> %4, <8 x i16>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.h [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size cle_u_v8i16<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @cle_u_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x<br>

>> > >> i32>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: cle_u_v4i32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x i32>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x i32>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp ule <4 x i32> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: cle_u.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size cle_u_v4i32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @cle_u_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x<br>

>> > >> i64>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: cle_u_v2i64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x i64>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x i64>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp ule <2 x i64> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: cle_u.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size cle_u_v2i64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clt_s_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16<br>

>> x<br>

>> > >> i8>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clt_s_v16i8:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <16 x i8>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <16 x i8>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp slt <16 x i8> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <16 x i1> %3 to <16 x i8><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clt_s.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <16 x i8> %4, <16 x i8>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.b [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clt_s_v16i8<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clt_s_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x<br>

>> > >> i16>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clt_s_v8i16:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <8 x i16>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <8 x i16>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp slt <8 x i16> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <8 x i1> %3 to <8 x i16><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clt_s.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <8 x i16> %4, <8 x i16>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.h [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clt_s_v8i16<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clt_s_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x<br>

>> > >> i32>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clt_s_v4i32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x i32>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x i32>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp slt <4 x i32> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clt_s.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clt_s_v4i32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clt_s_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x<br>

>> > >> i64>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clt_s_v2i64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x i64>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x i64>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp slt <2 x i64> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clt_s.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clt_s_v2i64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clt_u_v16i8(<16 x i8>* %c, <16 x i8>* %a, <16<br>

>> x<br>

>> > >> i8>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clt_u_v16i8:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <16 x i8>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <16 x i8>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp ult <16 x i8> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <16 x i1> %3 to <16 x i8><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clt_u.b [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <16 x i8> %4, <16 x i8>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.b [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clt_u_v16i8<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clt_u_v8i16(<8 x i16>* %c, <8 x i16>* %a, <8 x<br>

>> > >> i16>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clt_u_v8i16:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <8 x i16>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <8 x i16>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp ult <8 x i16> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <8 x i1> %3 to <8 x i16><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clt_u.h [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <8 x i16> %4, <8 x i16>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.h [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clt_u_v8i16<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clt_u_v4i32(<4 x i32>* %c, <4 x i32>* %a, <4 x<br>

>> > >> i32>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clt_u_v4i32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x i32>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x i32>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp ult <4 x i32> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clt_u.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clt_u_v4i32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clt_u_v2i64(<2 x i64>* %c, <2 x i64>* %a, <2 x<br>

>> > >> i64>* %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clt_u_v2i64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x i64>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x i64>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = icmp ult <2 x i64> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clt_u.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clt_u_v2i64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ceqi_v16i8(<16 x i8>* %c, <16 x i8>* %a)<br>

>> > nounwind<br>

>> > >> {<br>

>> > >> >>> > >> > +  ; CHECK: ceqi_v16i8:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <16 x i8>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp eq <16 x i8> %1, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1,<br>

>> > i8 1,<br>

>> > >> i8 1,<br>

>> > >> >>> > i8 1,<br>

>> > >> >>> > >> i8 1, i8 1, i8 1, i8 1, i8 1, i8 1><br>

>> > >> >>> > >> > +  %3 = sext <16 x i1> %2 to <16 x i8><br>

>> > >> >>> > >> > +  ; CHECK-DAG: ceqi.b [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <16 x i8> %3, <16 x i8>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.b [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ceqi_v16i8<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ceqi_v8i16(<8 x i16>* %c, <8 x i16>* %a)<br>

>> > nounwind<br>

>> > >> {<br>

>> > >> >>> > >> > +  ; CHECK: ceqi_v8i16:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <8 x i16>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp eq <8 x i16> %1, <i16 1, i16 1, i16 1, i16 1, i16 1,<br>

>> i16<br>

>> > 1,<br>

>> > >> i16 1,<br>

>> > >> >>> > i16 1><br>

>> > >> >>> > >> > +  %3 = sext <8 x i1> %2 to <8 x i16><br>

>> > >> >>> > >> > +  ; CHECK-DAG: ceqi.h [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <8 x i16> %3, <8 x i16>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.h [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ceqi_v8i16<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ceqi_v4i32(<4 x i32>* %c, <4 x i32>* %a)<br>

>> > nounwind<br>

>> > >> {<br>

>> > >> >>> > >> > +  ; CHECK: ceqi_v4i32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x i32>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp eq <4 x i32> %1, <i32 1, i32 1, i32 1, i32 1><br>

>> > >> >>> > >> > +  %3 = sext <4 x i1> %2 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: ceqi.w [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <4 x i32> %3, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ceqi_v4i32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ceqi_v2i64(<2 x i64>* %c, <2 x i64>* %a)<br>

>> > nounwind<br>

>> > >> {<br>

>> > >> >>> > >> > +  ; CHECK: ceqi_v2i64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x i64>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp eq <2 x i64> %1, <i64 1, i64 1><br>

>> > >> >>> > >> > +  %3 = sext <2 x i1> %2 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: ceqi.d [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <2 x i64> %3, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ceqi_v2i64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clei_s_v16i8(<16 x i8>* %c, <16 x i8>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clei_s_v16i8:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <16 x i8>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp sle <16 x i8> %1, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8<br>

>> 1,<br>

>> > i8 1,<br>

>> > >> i8<br>

>> > >> >>> 1,<br>

>> > >> >>> > i8 1,<br>

>> > >> >>> > >> i8 1, i8 1, i8 1, i8 1, i8 1, i8 1><br>

>> > >> >>> > >> > +  %3 = sext <16 x i1> %2 to <16 x i8><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clei_s.b [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <16 x i8> %3, <16 x i8>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.b [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clei_s_v16i8<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clei_s_v8i16(<8 x i16>* %c, <8 x i16>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clei_s_v8i16:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <8 x i16>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp sle <8 x i16> %1, <i16 1, i16 1, i16 1, i16 1, i16 1,<br>

>> i16<br>

>> > 1,<br>

>> > >> i16 1,<br>

>> > >> >>> > i16<br>

>> > >> >>> > >> 1><br>

>> > >> >>> > >> > +  %3 = sext <8 x i1> %2 to <8 x i16><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clei_s.h [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <8 x i16> %3, <8 x i16>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.h [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clei_s_v8i16<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clei_s_v4i32(<4 x i32>* %c, <4 x i32>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clei_s_v4i32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x i32>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp sle <4 x i32> %1, <i32 1, i32 1, i32 1, i32 1><br>

>> > >> >>> > >> > +  %3 = sext <4 x i1> %2 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clei_s.w [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <4 x i32> %3, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clei_s_v4i32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clei_s_v2i64(<2 x i64>* %c, <2 x i64>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clei_s_v2i64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x i64>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp sle <2 x i64> %1, <i64 1, i64 1><br>

>> > >> >>> > >> > +  %3 = sext <2 x i1> %2 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clei_s.d [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <2 x i64> %3, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clei_s_v2i64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clei_u_v16i8(<16 x i8>* %c, <16 x i8>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clei_u_v16i8:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <16 x i8>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp ule <16 x i8> %1, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8<br>

>> 1,<br>

>> > i8 1,<br>

>> > >> i8<br>

>> > >> >>> 1,<br>

>> > >> >>> > i8 1,<br>

>> > >> >>> > >> i8 1, i8 1, i8 1, i8 1, i8 1, i8 1><br>

>> > >> >>> > >> > +  %3 = sext <16 x i1> %2 to <16 x i8><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clei_u.b [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <16 x i8> %3, <16 x i8>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.b [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clei_u_v16i8<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clei_u_v8i16(<8 x i16>* %c, <8 x i16>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clei_u_v8i16:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <8 x i16>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp ule <8 x i16> %1, <i16 1, i16 1, i16 1, i16 1, i16 1,<br>

>> i16<br>

>> > 1,<br>

>> > >> i16 1,<br>

>> > >> >>> > i16<br>

>> > >> >>> > >> 1><br>

>> > >> >>> > >> > +  %3 = sext <8 x i1> %2 to <8 x i16><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clei_u.h [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <8 x i16> %3, <8 x i16>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.h [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clei_u_v8i16<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clei_u_v4i32(<4 x i32>* %c, <4 x i32>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clei_u_v4i32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x i32>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp ule <4 x i32> %1, <i32 1, i32 1, i32 1, i32 1><br>

>> > >> >>> > >> > +  %3 = sext <4 x i1> %2 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clei_u.w [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <4 x i32> %3, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clei_u_v4i32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clei_u_v2i64(<2 x i64>* %c, <2 x i64>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clei_u_v2i64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x i64>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp ule <2 x i64> %1, <i64 1, i64 1><br>

>> > >> >>> > >> > +  %3 = sext <2 x i1> %2 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clei_u.d [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <2 x i64> %3, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clei_u_v2i64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clti_s_v16i8(<16 x i8>* %c, <16 x i8>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clti_s_v16i8:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <16 x i8>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp slt <16 x i8> %1, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1,<br>

>> i8<br>

>> > 1,<br>

>> > >> i8 1,<br>

>> > >> >>> > i8 1,<br>

>> > >> >>> > >> i8 1, i8 1, i8 1, i8 1, i8 1, i8 1><br>

>> > >> >>> > >> > +  %3 = sext <16 x i1> %2 to <16 x i8><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clti_s.b [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <16 x i8> %3, <16 x i8>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.b [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clti_s_v16i8<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clti_s_v8i16(<8 x i16>* %c, <8 x i16>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clti_s_v8i16:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <8 x i16>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp slt <8 x i16> %1, <i16 1, i16 1, i16 1, i16 1, i16 1, i16<br>

>> > 1,<br>

>> > >> i16 1,<br>

>> > >> >>> > i16 1><br>

>> > >> >>> > >> > +  %3 = sext <8 x i1> %2 to <8 x i16><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clti_s.h [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <8 x i16> %3, <8 x i16>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.h [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clti_s_v8i16<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clti_s_v4i32(<4 x i32>* %c, <4 x i32>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clti_s_v4i32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x i32>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp slt <4 x i32> %1, <i32 1, i32 1, i32 1, i32 1><br>

>> > >> >>> > >> > +  %3 = sext <4 x i1> %2 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clti_s.w [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <4 x i32> %3, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clti_s_v4i32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clti_s_v2i64(<2 x i64>* %c, <2 x i64>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clti_s_v2i64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x i64>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp slt <2 x i64> %1, <i64 1, i64 1><br>

>> > >> >>> > >> > +  %3 = sext <2 x i1> %2 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clti_s.d [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <2 x i64> %3, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clti_s_v2i64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clti_u_v16i8(<16 x i8>* %c, <16 x i8>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clti_u_v16i8:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <16 x i8>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.b [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp ult <16 x i8> %1, <i8 1, i8 1, i8 1, i8 1, i8 1, i8 1, i8 1,<br>

>> > i8 1,<br>

>> > >> i8 1,<br>

>> > >> >>> > i8 1,<br>

>> > >> >>> > >> i8 1, i8 1, i8 1, i8 1, i8 1, i8 1><br>

>> > >> >>> > >> > +  %3 = sext <16 x i1> %2 to <16 x i8><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clti_u.b [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <16 x i8> %3, <16 x i8>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.b [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clti_u_v16i8<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clti_u_v8i16(<8 x i16>* %c, <8 x i16>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clti_u_v8i16:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <8 x i16>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.h [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp ult <8 x i16> %1, <i16 1, i16 1, i16 1, i16 1, i16 1,<br>

>> i16<br>

>> > 1,<br>

>> > >> i16 1,<br>

>> > >> >>> > i16 1><br>

>> > >> >>> > >> > +  %3 = sext <8 x i1> %2 to <8 x i16><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clti_u.h [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <8 x i16> %3, <8 x i16>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.h [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clti_u_v8i16<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clti_u_v4i32(<4 x i32>* %c, <4 x i32>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clti_u_v4i32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x i32>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp ult <4 x i32> %1, <i32 1, i32 1, i32 1, i32 1><br>

>> > >> >>> > >> > +  %3 = sext <4 x i1> %2 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clti_u.w [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <4 x i32> %3, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clti_u_v4i32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @clti_u_v2i64(<2 x i64>* %c, <2 x i64>* %a)<br>

>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: clti_u_v2i64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x i64>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = icmp ult <2 x i64> %1, <i64 1, i64 1><br>

>> > >> >>> > >> > +  %3 = sext <2 x i1> %2 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: clti_u.d [[R3:\$w[0-9]+]], [[R1]], 1<br>

>> > >> >>> > >> > +  store <2 x i64> %3, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size clti_u_v2i64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >> > Added:<br>

>> llvm/trunk/test/CodeGen/Mips/msa/compare_float.ll<br>

>> > >> >>> > >> > URL: <a href="http://llvm.org/viewvc/llvm-" target="_blank">http://llvm.org/viewvc/llvm-</a><br>

>> > >> >>> > >><br>

>> > >> >>> ><br>

>> > >> >>><br>

>> > >><br>

>> ><br>

>> project/llvm/trunk/test/CodeGen/Mips/msa/compare_float.ll?rev=191286&<br>

>> > >> >>> > >> view=auto<br>

>> > >> >>> > >> ><br>

>> > >> >>> > >><br>

>> > >><br>

>> ><br>

>> ==========================================================<br>

>> > >> >>> > >> ====================<br>

>> > >> >>> > >> > --- llvm/trunk/test/CodeGen/Mips/msa/compare_float.ll<br>

>> > (added)<br>

>> > >> >>> > >> > +++ llvm/trunk/test/CodeGen/Mips/msa/compare_float.ll<br>

>> > Tue<br>

>> > >> Sep 24<br>

>> > >> >>> > >> 05:46:19 2013<br>

>> > >> >>> > >> > @@ -0,0 +1,518 @@<br>

>> > >> >>> > >> > +; RUN: llc -march=mips -mattr=+msa < %s | FileCheck %s<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +declare <4 x float> @llvm.mips.fmax.w(<4 x float>, <4 x<br>

>> > float>)<br>

>> > >> >>> > nounwind<br>

>> > >> >>> > >> > +declare <2 x double> @llvm.mips.fmax.d(<2 x double>, <2 x<br>

>> > >> double>)<br>

>> > >> >>> > >> nounwind<br>

>> > >> >>> > >> > +declare <4 x float> @llvm.mips.fmin.w(<4 x float>, <4 x<br>

>> > float>)<br>

>> > >> >>> > nounwind<br>

>> > >> >>> > >> > +declare <2 x double> @llvm.mips.fmin.d(<2 x double>, <2 x<br>

>> > >> double>)<br>

>> > >> >>> > >> nounwind<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @false_v4f32(<4 x i32>* %c, <4 x float>* %a, <4<br>

>> x<br>

>> > >> float>*<br>

>> > >> >>> > %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: false_v4f32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x float>* %a<br>

>> > >> >>> > >> > +  %2 = load <4 x float>* %b<br>

>> > >> >>> > >> > +  %3 = fcmp false <4 x float> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ; (setcc $a, $b, SETFALSE) is always folded, so we won't get<br>

>> > fcaf:<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ldi.b [[R1:\$w[0-9]+]], 0<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.b [[R1]], 0($4)<br>

>> > >> >>> > >> > +  ; CHECK: .size false_v4f32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @false_v2f64(<2 x i64>* %c, <2 x double>* %a,<br>

>> > <2 x<br>

>> > >> >>> > double>*<br>

>> > >> >>> > >> %b) nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: false_v2f64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x double>* %a<br>

>> > >> >>> > >> > +  %2 = load <2 x double>* %b<br>

>> > >> >>> > >> > +  %3 = fcmp false <2 x double> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ; FIXME: This code is correct, but poor. Ideally it would be<br>

>> > similar<br>

>> > >> to<br>

>> > >> >>> > >> > +  ;        the code in @false_v4f32<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ldi.b [[R1:\$w[0-9]+]], 0<br>

>> > >> >>> > >> > +  ; CHECK-DAG: slli.d [[R3:\$w[0-9]+]], [[R1]], 63<br>

>> > >> >>> > >> > +  ; CHECK-DAG: srai.d [[R4:\$w[0-9]+]], [[R3]], 63<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R4]], 0($4)<br>

>> > >> >>> > >> > +  ; CHECK: .size false_v2f64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @oeq_v4f32(<4 x i32>* %c, <4 x float>* %a, <4<br>

>> x<br>

>> > >> float>*<br>

>> > >> >>> > %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: oeq_v4f32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x float>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x float>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp oeq <4 x float> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fceq.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size oeq_v4f32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @oeq_v2f64(<2 x i64>* %c, <2 x double>* %a,<br>

>> <2<br>

>> > x<br>

>> > >> >>> > double>*<br>

>> > >> >>> > >> %b) nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: oeq_v2f64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x double>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x double>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp oeq <2 x double> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fceq.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size oeq_v2f64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @oge_v4f32(<4 x i32>* %c, <4 x float>* %a, <4<br>

>> x<br>

>> > >> float>*<br>

>> > >> >>> %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: oge_v4f32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x float>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x float>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp oge <4 x float> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fcle.w [[R3:\$w[0-9]+]], [[R2]], [[R1]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size oge_v4f32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @oge_v2f64(<2 x i64>* %c, <2 x double>* %a,<br>

>> <2<br>

>> > x<br>

>> > >> >>> > double>*<br>

>> > >> >>> > >> %b) nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: oge_v2f64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x double>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x double>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp oge <2 x double> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fcle.d [[R3:\$w[0-9]+]], [[R2]], [[R1]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size oge_v2f64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ogt_v4f32(<4 x i32>* %c, <4 x float>* %a, <4 x<br>

>> > >> float>*<br>

>> > >> >>> %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ogt_v4f32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x float>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x float>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp ogt <4 x float> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fclt.w [[R3:\$w[0-9]+]], [[R2]], [[R1]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ogt_v4f32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ogt_v2f64(<2 x i64>* %c, <2 x double>* %a,<br>

>> <2<br>

>> > x<br>

>> > >> >>> double>*<br>

>> > >> >>> > >> %b) nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ogt_v2f64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x double>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x double>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp ogt <2 x double> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fclt.d [[R3:\$w[0-9]+]], [[R2]], [[R1]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ogt_v2f64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ole_v4f32(<4 x i32>* %c, <4 x float>* %a, <4 x<br>

>> > >> float>*<br>

>> > >> >>> %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ole_v4f32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x float>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x float>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp ole <4 x float> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fcle.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ole_v4f32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ole_v2f64(<2 x i64>* %c, <2 x double>* %a,<br>

>> <2<br>

>> > x<br>

>> > >> >>> double>*<br>

>> > >> >>> > >> %b) nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ole_v2f64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x double>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x double>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp ole <2 x double> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fcle.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ole_v2f64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @olt_v4f32(<4 x i32>* %c, <4 x float>* %a, <4 x<br>

>> > >> float>*<br>

>> > >> >>> %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: olt_v4f32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x float>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x float>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp olt <4 x float> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fclt.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size olt_v4f32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @olt_v2f64(<2 x i64>* %c, <2 x double>* %a,<br>

>> <2 x<br>

>> > >> >>> double>*<br>

>> > >> >>> > >> %b) nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: olt_v2f64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x double>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x double>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp olt <2 x double> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fclt.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size olt_v2f64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @one_v4f32(<4 x i32>* %c, <4 x float>* %a, <4<br>

>> x<br>

>> > >> float>*<br>

>> > >> >>> > %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: one_v4f32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x float>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x float>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp one <4 x float> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fcne.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size one_v4f32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @one_v2f64(<2 x i64>* %c, <2 x double>* %a,<br>

>> <2<br>

>> > x<br>

>> > >> >>> > double>*<br>

>> > >> >>> > >> %b) nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: one_v2f64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x double>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x double>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp one <2 x double> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fcne.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size one_v2f64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ord_v4f32(<4 x i32>* %c, <4 x float>* %a, <4<br>

>> x<br>

>> > >> float>*<br>

>> > >> >>> %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ord_v4f32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x float>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x float>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp ord <4 x float> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fcor.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ord_v4f32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ord_v2f64(<2 x i64>* %c, <2 x double>* %a,<br>

>> <2<br>

>> > x<br>

>> > >> >>> > double>*<br>

>> > >> >>> > >> %b) nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ord_v2f64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x double>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x double>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp ord <2 x double> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fcor.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <2 x i64> %4, <2 x i64>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.d [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ord_v2f64<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ueq_v4f32(<4 x i32>* %c, <4 x float>* %a, <4<br>

>> x<br>

>> > >> float>*<br>

>> > >> >>> > %b)<br>

>> > >> >>> > >> nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ueq_v4f32:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <4 x float>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <4 x float>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.w [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp ueq <4 x float> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <4 x i1> %3 to <4 x i32><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fcueq.w [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <4 x i32> %4, <4 x i32>* %c<br>

>> > >> >>> > >> > +  ; CHECK-DAG: st.w [[R3]], 0($4)<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  ret void<br>

>> > >> >>> > >> > +  ; CHECK: .size ueq_v4f32<br>

>> > >> >>> > >> > +}<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +define void @ueq_v2f64(<2 x i64>* %c, <2 x double>* %a,<br>

>> <2<br>

>> > x<br>

>> > >> >>> > double>*<br>

>> > >> >>> > >> %b) nounwind {<br>

>> > >> >>> > >> > +  ; CHECK: ueq_v2f64:<br>

>> > >> >>> > >> > +<br>

>> > >> >>> > >> > +  %1 = load <2 x double>* %a<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R1:\$w[0-9]+]], 0($5)<br>

>> > >> >>> > >> > +  %2 = load <2 x double>* %b<br>

>> > >> >>> > >> > +  ; CHECK-DAG: ld.d [[R2:\$w[0-9]+]], 0($6)<br>

>> > >> >>> > >> > +  %3 = fcmp ueq <2 x double> %1, %2<br>

>> > >> >>> > >> > +  %4 = sext <2 x i1> %3 to <2 x i64><br>

>> > >> >>> > >> > +  ; CHECK-DAG: fcueq.d [[R3:\$w[0-9]+]], [[R1]], [[R2]]<br>

>> > >> >>> > >> > +  store <2 x i6...</blockquote></div>