1// Code generated from _gen/386.rules using 'go generate'; DO NOT EDIT.23package i38645import "math"6import "cmd/compile/internal/types"7import "cmd/compile/internal/ssa/block"8import "cmd/compile/internal/ssa/ssaop"9import "cmd/compile/internal/ssa"1011func RewriteValue(v *ssa.Value) bool {12	switch v.Op {13	case ssaop.Op386ADCL:14		return rewriteValue_Op386ADCL(v)15	case ssaop.Op386ADDL:16		return rewriteValue_Op386ADDL(v)17	case ssaop.Op386ADDLcarry:18		return rewriteValue_Op386ADDLcarry(v)19	case ssaop.Op386ADDLconst:20		return rewriteValue_Op386ADDLconst(v)21	case ssaop.Op386ADDLconstmodify:22		return rewriteValue_Op386ADDLconstmodify(v)23	case ssaop.Op386ADDLload:24		return rewriteValue_Op386ADDLload(v)25	case ssaop.Op386ADDLmodify:26		return rewriteValue_Op386ADDLmodify(v)27	case ssaop.Op386ADDSD:28		return rewriteValue_Op386ADDSD(v)29	case ssaop.Op386ADDSDload:30		return rewriteValue_Op386ADDSDload(v)31	case ssaop.Op386ADDSS:32		return rewriteValue_Op386ADDSS(v)33	case ssaop.Op386ADDSSload:34		return rewriteValue_Op386ADDSSload(v)35	case ssaop.Op386ANDL:36		return rewriteValue_Op386ANDL(v)37	case ssaop.Op386ANDLconst:38		return rewriteValue_Op386ANDLconst(v)39	case ssaop.Op386ANDLconstmodify:40		return rewriteValue_Op386ANDLconstmodify(v)41	case ssaop.Op386ANDLload:42		return rewriteValue_Op386ANDLload(v)43	case ssaop.Op386ANDLmodify:44		return rewriteValue_Op386ANDLmodify(v)45	case ssaop.Op386CMPB:46		return rewriteValue_Op386CMPB(v)47	case ssaop.Op386CMPBconst:48		return rewriteValue_Op386CMPBconst(v)49	case ssaop.Op386CMPBload:50		return rewriteValue_Op386CMPBload(v)51	case ssaop.Op386CMPL:52		return rewriteValue_Op386CMPL(v)53	case ssaop.Op386CMPLconst:54		return rewriteValue_Op386CMPLconst(v)55	case ssaop.Op386CMPLload:56		return rewriteValue_Op386CMPLload(v)57	case ssaop.Op386CMPW:58		return rewriteValue_Op386CMPW(v)59	case ssaop.Op386CMPWconst:60		return rewriteValue_Op386CMPWconst(v)61	case ssaop.Op386CMPWload:62		return rewriteValue_Op386CMPWload(v)63	case ssaop.Op386DIVSD:64		return rewriteValue_Op386DIVSD(v)65	case ssaop.Op386DIVSDload:66		return rewriteValue_Op386DIVSDload(v)67	case ssaop.Op386DIVSS:68		return rewriteValue_Op386DIVSS(v)69	case ssaop.Op386DIVSSload:70		return rewriteValue_Op386DIVSSload(v)71	case ssaop.Op386LEAL:72		return rewriteValue_Op386LEAL(v)73	case ssaop.Op386LEAL1:74		return rewriteValue_Op386LEAL1(v)75	case ssaop.Op386LEAL2:76		return rewriteValue_Op386LEAL2(v)77	case ssaop.Op386LEAL4:78		return rewriteValue_Op386LEAL4(v)79	case ssaop.Op386LEAL8:80		return rewriteValue_Op386LEAL8(v)81	case ssaop.Op386LoweredPanicBoundsRC:82		return rewriteValue_Op386LoweredPanicBoundsRC(v)83	case ssaop.Op386LoweredPanicBoundsRR:84		return rewriteValue_Op386LoweredPanicBoundsRR(v)85	case ssaop.Op386LoweredPanicExtendRC:86		return rewriteValue_Op386LoweredPanicExtendRC(v)87	case ssaop.Op386LoweredPanicExtendRR:88		return rewriteValue_Op386LoweredPanicExtendRR(v)89	case ssaop.Op386MOVBLSX:90		return rewriteValue_Op386MOVBLSX(v)91	case ssaop.Op386MOVBLSXload:92		return rewriteValue_Op386MOVBLSXload(v)93	case ssaop.Op386MOVBLZX:94		return rewriteValue_Op386MOVBLZX(v)95	case ssaop.Op386MOVBload:96		return rewriteValue_Op386MOVBload(v)97	case ssaop.Op386MOVBstore:98		return rewriteValue_Op386MOVBstore(v)99	case ssaop.Op386MOVBstoreconst:100		return rewriteValue_Op386MOVBstoreconst(v)101	case ssaop.Op386MOVLload:102		return rewriteValue_Op386MOVLload(v)103	case ssaop.Op386MOVLstore:104		return rewriteValue_Op386MOVLstore(v)105	case ssaop.Op386MOVLstoreconst:106		return rewriteValue_Op386MOVLstoreconst(v)107	case ssaop.Op386MOVSDconst:108		return rewriteValue_Op386MOVSDconst(v)109	case ssaop.Op386MOVSDload:110		return rewriteValue_Op386MOVSDload(v)111	case ssaop.Op386MOVSDstore:112		return rewriteValue_Op386MOVSDstore(v)113	case ssaop.Op386MOVSSconst:114		return rewriteValue_Op386MOVSSconst(v)115	case ssaop.Op386MOVSSload:116		return rewriteValue_Op386MOVSSload(v)117	case ssaop.Op386MOVSSstore:118		return rewriteValue_Op386MOVSSstore(v)119	case ssaop.Op386MOVWLSX:120		return rewriteValue_Op386MOVWLSX(v)121	case ssaop.Op386MOVWLSXload:122		return rewriteValue_Op386MOVWLSXload(v)123	case ssaop.Op386MOVWLZX:124		return rewriteValue_Op386MOVWLZX(v)125	case ssaop.Op386MOVWload:126		return rewriteValue_Op386MOVWload(v)127	case ssaop.Op386MOVWstore:128		return rewriteValue_Op386MOVWstore(v)129	case ssaop.Op386MOVWstoreconst:130		return rewriteValue_Op386MOVWstoreconst(v)131	case ssaop.Op386MULL:132		return rewriteValue_Op386MULL(v)133	case ssaop.Op386MULLconst:134		return rewriteValue_Op386MULLconst(v)135	case ssaop.Op386MULLload:136		return rewriteValue_Op386MULLload(v)137	case ssaop.Op386MULSD:138		return rewriteValue_Op386MULSD(v)139	case ssaop.Op386MULSDload:140		return rewriteValue_Op386MULSDload(v)141	case ssaop.Op386MULSS:142		return rewriteValue_Op386MULSS(v)143	case ssaop.Op386MULSSload:144		return rewriteValue_Op386MULSSload(v)145	case ssaop.Op386NEGL:146		return rewriteValue_Op386NEGL(v)147	case ssaop.Op386NOTL:148		return rewriteValue_Op386NOTL(v)149	case ssaop.Op386ORL:150		return rewriteValue_Op386ORL(v)151	case ssaop.Op386ORLconst:152		return rewriteValue_Op386ORLconst(v)153	case ssaop.Op386ORLconstmodify:154		return rewriteValue_Op386ORLconstmodify(v)155	case ssaop.Op386ORLload:156		return rewriteValue_Op386ORLload(v)157	case ssaop.Op386ORLmodify:158		return rewriteValue_Op386ORLmodify(v)159	case ssaop.Op386ROLB:160		return rewriteValue_Op386ROLB(v)161	case ssaop.Op386ROLBconst:162		return rewriteValue_Op386ROLBconst(v)163	case ssaop.Op386ROLL:164		return rewriteValue_Op386ROLL(v)165	case ssaop.Op386ROLLconst:166		return rewriteValue_Op386ROLLconst(v)167	case ssaop.Op386ROLW:168		return rewriteValue_Op386ROLW(v)169	case ssaop.Op386ROLWconst:170		return rewriteValue_Op386ROLWconst(v)171	case ssaop.Op386SARB:172		return rewriteValue_Op386SARB(v)173	case ssaop.Op386SARBconst:174		return rewriteValue_Op386SARBconst(v)175	case ssaop.Op386SARL:176		return rewriteValue_Op386SARL(v)177	case ssaop.Op386SARLconst:178		return rewriteValue_Op386SARLconst(v)179	case ssaop.Op386SARW:180		return rewriteValue_Op386SARW(v)181	case ssaop.Op386SARWconst:182		return rewriteValue_Op386SARWconst(v)183	case ssaop.Op386SBBL:184		return rewriteValue_Op386SBBL(v)185	case ssaop.Op386SBBLcarrymask:186		return rewriteValue_Op386SBBLcarrymask(v)187	case ssaop.Op386SETA:188		return rewriteValue_Op386SETA(v)189	case ssaop.Op386SETAE:190		return rewriteValue_Op386SETAE(v)191	case ssaop.Op386SETB:192		return rewriteValue_Op386SETB(v)193	case ssaop.Op386SETBE:194		return rewriteValue_Op386SETBE(v)195	case ssaop.Op386SETEQ:196		return rewriteValue_Op386SETEQ(v)197	case ssaop.Op386SETG:198		return rewriteValue_Op386SETG(v)199	case ssaop.Op386SETGE:200		return rewriteValue_Op386SETGE(v)201	case ssaop.Op386SETL:202		return rewriteValue_Op386SETL(v)203	case ssaop.Op386SETLE:204		return rewriteValue_Op386SETLE(v)205	case ssaop.Op386SETNE:206		return rewriteValue_Op386SETNE(v)207	case ssaop.Op386SHLL:208		return rewriteValue_Op386SHLL(v)209	case ssaop.Op386SHLLconst:210		return rewriteValue_Op386SHLLconst(v)211	case ssaop.Op386SHRB:212		return rewriteValue_Op386SHRB(v)213	case ssaop.Op386SHRBconst:214		return rewriteValue_Op386SHRBconst(v)215	case ssaop.Op386SHRL:216		return rewriteValue_Op386SHRL(v)217	case ssaop.Op386SHRLconst:218		return rewriteValue_Op386SHRLconst(v)219	case ssaop.Op386SHRW:220		return rewriteValue_Op386SHRW(v)221	case ssaop.Op386SHRWconst:222		return rewriteValue_Op386SHRWconst(v)223	case ssaop.Op386SUBL:224		return rewriteValue_Op386SUBL(v)225	case ssaop.Op386SUBLcarry:226		return rewriteValue_Op386SUBLcarry(v)227	case ssaop.Op386SUBLconst:228		return rewriteValue_Op386SUBLconst(v)229	case ssaop.Op386SUBLload:230		return rewriteValue_Op386SUBLload(v)231	case ssaop.Op386SUBLmodify:232		return rewriteValue_Op386SUBLmodify(v)233	case ssaop.Op386SUBSD:234		return rewriteValue_Op386SUBSD(v)235	case ssaop.Op386SUBSDload:236		return rewriteValue_Op386SUBSDload(v)237	case ssaop.Op386SUBSS:238		return rewriteValue_Op386SUBSS(v)239	case ssaop.Op386SUBSSload:240		return rewriteValue_Op386SUBSSload(v)241	case ssaop.Op386XORL:242		return rewriteValue_Op386XORL(v)243	case ssaop.Op386XORLconst:244		return rewriteValue_Op386XORLconst(v)245	case ssaop.Op386XORLconstmodify:246		return rewriteValue_Op386XORLconstmodify(v)247	case ssaop.Op386XORLload:248		return rewriteValue_Op386XORLload(v)249	case ssaop.Op386XORLmodify:250		return rewriteValue_Op386XORLmodify(v)251	case ssaop.OpAdd16:252		v.Op = ssaop.Op386ADDL253		return true254	case ssaop.OpAdd32:255		v.Op = ssaop.Op386ADDL256		return true257	case ssaop.OpAdd32F:258		v.Op = ssaop.Op386ADDSS259		return true260	case ssaop.OpAdd32carry:261		v.Op = ssaop.Op386ADDLcarry262		return true263	case ssaop.OpAdd32carrywithcarry:264		v.Op = ssaop.Op386ADCLcarry265		return true266	case ssaop.OpAdd32withcarry:267		v.Op = ssaop.Op386ADCL268		return true269	case ssaop.OpAdd64F:270		v.Op = ssaop.Op386ADDSD271		return true272	case ssaop.OpAdd8:273		v.Op = ssaop.Op386ADDL274		return true275	case ssaop.OpAddPtr:276		v.Op = ssaop.Op386ADDL277		return true278	case ssaop.OpAddr:279		return rewriteValue_OpAddr(v)280	case ssaop.OpAnd16:281		v.Op = ssaop.Op386ANDL282		return true283	case ssaop.OpAnd32:284		v.Op = ssaop.Op386ANDL285		return true286	case ssaop.OpAnd8:287		v.Op = ssaop.Op386ANDL288		return true289	case ssaop.OpAndB:290		v.Op = ssaop.Op386ANDL291		return true292	case ssaop.OpAvg32u:293		v.Op = ssaop.Op386AVGLU294		return true295	case ssaop.OpBswap16:296		return rewriteValue_OpBswap16(v)297	case ssaop.OpBswap32:298		v.Op = ssaop.Op386BSWAPL299		return true300	case ssaop.OpClosureCall:301		v.Op = ssaop.Op386CALLclosure302		return true303	case ssaop.OpCom16:304		v.Op = ssaop.Op386NOTL305		return true306	case ssaop.OpCom32:307		v.Op = ssaop.Op386NOTL308		return true309	case ssaop.OpCom8:310		v.Op = ssaop.Op386NOTL311		return true312	case ssaop.OpConst16:313		return rewriteValue_OpConst16(v)314	case ssaop.OpConst32:315		v.Op = ssaop.Op386MOVLconst316		return true317	case ssaop.OpConst32F:318		v.Op = ssaop.Op386MOVSSconst319		return true320	case ssaop.OpConst64F:321		v.Op = ssaop.Op386MOVSDconst322		return true323	case ssaop.OpConst8:324		return rewriteValue_OpConst8(v)325	case ssaop.OpConstBool:326		return rewriteValue_OpConstBool(v)327	case ssaop.OpConstNil:328		return rewriteValue_OpConstNil(v)329	case ssaop.OpCtz16:330		return rewriteValue_OpCtz16(v)331	case ssaop.OpCtz16NonZero:332		v.Op = ssaop.Op386BSFL333		return true334	case ssaop.OpCtz32:335		v.Op = ssaop.Op386LoweredCtz32336		return true337	case ssaop.OpCtz32NonZero:338		v.Op = ssaop.Op386BSFL339		return true340	case ssaop.OpCtz64On32:341		v.Op = ssaop.Op386LoweredCtz64342		return true343	case ssaop.OpCtz8:344		return rewriteValue_OpCtz8(v)345	case ssaop.OpCtz8NonZero:346		v.Op = ssaop.Op386BSFL347		return true348	case ssaop.OpCvt32Fto32:349		v.Op = ssaop.Op386CVTTSS2SL350		return true351	case ssaop.OpCvt32Fto64F:352		v.Op = ssaop.Op386CVTSS2SD353		return true354	case ssaop.OpCvt32to32F:355		v.Op = ssaop.Op386CVTSL2SS356		return true357	case ssaop.OpCvt32to64F:358		v.Op = ssaop.Op386CVTSL2SD359		return true360	case ssaop.OpCvt64Fto32:361		v.Op = ssaop.Op386CVTTSD2SL362		return true363	case ssaop.OpCvt64Fto32F:364		v.Op = ssaop.Op386CVTSD2SS365		return true366	case ssaop.OpCvtBoolToUint8:367		v.Op = ssaop.OpCopy368		return true369	case ssaop.OpDiv16:370		v.Op = ssaop.Op386DIVW371		return true372	case ssaop.OpDiv16u:373		v.Op = ssaop.Op386DIVWU374		return true375	case ssaop.OpDiv32:376		v.Op = ssaop.Op386DIVL377		return true378	case ssaop.OpDiv32F:379		v.Op = ssaop.Op386DIVSS380		return true381	case ssaop.OpDiv32u:382		v.Op = ssaop.Op386DIVLU383		return true384	case ssaop.OpDiv64F:385		v.Op = ssaop.Op386DIVSD386		return true387	case ssaop.OpDiv8:388		return rewriteValue_OpDiv8(v)389	case ssaop.OpDiv8u:390		return rewriteValue_OpDiv8u(v)391	case ssaop.OpEq16:392		return rewriteValue_OpEq16(v)393	case ssaop.OpEq32:394		return rewriteValue_OpEq32(v)395	case ssaop.OpEq32F:396		return rewriteValue_OpEq32F(v)397	case ssaop.OpEq64F:398		return rewriteValue_OpEq64F(v)399	case ssaop.OpEq8:400		return rewriteValue_OpEq8(v)401	case ssaop.OpEqB:402		return rewriteValue_OpEqB(v)403	case ssaop.OpEqPtr:404		return rewriteValue_OpEqPtr(v)405	case ssaop.OpGetCallerPC:406		v.Op = ssaop.Op386LoweredGetCallerPC407		return true408	case ssaop.OpGetCallerSP:409		v.Op = ssaop.Op386LoweredGetCallerSP410		return true411	case ssaop.OpGetClosurePtr:412		v.Op = ssaop.Op386LoweredGetClosurePtr413		return true414	case ssaop.OpGetG:415		v.Op = ssaop.Op386LoweredGetG416		return true417	case ssaop.OpHmul32:418		v.Op = ssaop.Op386HMULL419		return true420	case ssaop.OpHmul32u:421		v.Op = ssaop.Op386HMULLU422		return true423	case ssaop.OpInterCall:424		v.Op = ssaop.Op386CALLinter425		return true426	case ssaop.OpIsInBounds:427		return rewriteValue_OpIsInBounds(v)428	case ssaop.OpIsNonNil:429		return rewriteValue_OpIsNonNil(v)430	case ssaop.OpIsSliceInBounds:431		return rewriteValue_OpIsSliceInBounds(v)432	case ssaop.OpLeq16:433		return rewriteValue_OpLeq16(v)434	case ssaop.OpLeq16U:435		return rewriteValue_OpLeq16U(v)436	case ssaop.OpLeq32:437		return rewriteValue_OpLeq32(v)438	case ssaop.OpLeq32F:439		return rewriteValue_OpLeq32F(v)440	case ssaop.OpLeq32U:441		return rewriteValue_OpLeq32U(v)442	case ssaop.OpLeq64F:443		return rewriteValue_OpLeq64F(v)444	case ssaop.OpLeq8:445		return rewriteValue_OpLeq8(v)446	case ssaop.OpLeq8U:447		return rewriteValue_OpLeq8U(v)448	case ssaop.OpLess16:449		return rewriteValue_OpLess16(v)450	case ssaop.OpLess16U:451		return rewriteValue_OpLess16U(v)452	case ssaop.OpLess32:453		return rewriteValue_OpLess32(v)454	case ssaop.OpLess32F:455		return rewriteValue_OpLess32F(v)456	case ssaop.OpLess32U:457		return rewriteValue_OpLess32U(v)458	case ssaop.OpLess64F:459		return rewriteValue_OpLess64F(v)460	case ssaop.OpLess8:461		return rewriteValue_OpLess8(v)462	case ssaop.OpLess8U:463		return rewriteValue_OpLess8U(v)464	case ssaop.OpLoad:465		return rewriteValue_OpLoad(v)466	case ssaop.OpLocalAddr:467		return rewriteValue_OpLocalAddr(v)468	case ssaop.OpLsh16x16:469		return rewriteValue_OpLsh16x16(v)470	case ssaop.OpLsh16x32:471		return rewriteValue_OpLsh16x32(v)472	case ssaop.OpLsh16x64:473		return rewriteValue_OpLsh16x64(v)474	case ssaop.OpLsh16x8:475		return rewriteValue_OpLsh16x8(v)476	case ssaop.OpLsh32x16:477		return rewriteValue_OpLsh32x16(v)478	case ssaop.OpLsh32x32:479		return rewriteValue_OpLsh32x32(v)480	case ssaop.OpLsh32x64:481		return rewriteValue_OpLsh32x64(v)482	case ssaop.OpLsh32x8:483		return rewriteValue_OpLsh32x8(v)484	case ssaop.OpLsh8x16:485		return rewriteValue_OpLsh8x16(v)486	case ssaop.OpLsh8x32:487		return rewriteValue_OpLsh8x32(v)488	case ssaop.OpLsh8x64:489		return rewriteValue_OpLsh8x64(v)490	case ssaop.OpLsh8x8:491		return rewriteValue_OpLsh8x8(v)492	case ssaop.OpMod16:493		v.Op = ssaop.Op386MODW494		return true495	case ssaop.OpMod16u:496		v.Op = ssaop.Op386MODWU497		return true498	case ssaop.OpMod32:499		v.Op = ssaop.Op386MODL500		return true501	case ssaop.OpMod32u:502		v.Op = ssaop.Op386MODLU503		return true504	case ssaop.OpMod8:505		return rewriteValue_OpMod8(v)506	case ssaop.OpMod8u:507		return rewriteValue_OpMod8u(v)508	case ssaop.OpMove:509		return rewriteValue_OpMove(v)510	case ssaop.OpMul16:511		v.Op = ssaop.Op386MULL512		return true513	case ssaop.OpMul32:514		v.Op = ssaop.Op386MULL515		return true516	case ssaop.OpMul32F:517		v.Op = ssaop.Op386MULSS518		return true519	case ssaop.OpMul32uhilo:520		v.Op = ssaop.Op386MULLQU521		return true522	case ssaop.OpMul64F:523		v.Op = ssaop.Op386MULSD524		return true525	case ssaop.OpMul8:526		v.Op = ssaop.Op386MULL527		return true528	case ssaop.OpNeg16:529		v.Op = ssaop.Op386NEGL530		return true531	case ssaop.OpNeg32:532		v.Op = ssaop.Op386NEGL533		return true534	case ssaop.OpNeg32F:535		return rewriteValue_OpNeg32F(v)536	case ssaop.OpNeg64F:537		return rewriteValue_OpNeg64F(v)538	case ssaop.OpNeg8:539		v.Op = ssaop.Op386NEGL540		return true541	case ssaop.OpNeq16:542		return rewriteValue_OpNeq16(v)543	case ssaop.OpNeq32:544		return rewriteValue_OpNeq32(v)545	case ssaop.OpNeq32F:546		return rewriteValue_OpNeq32F(v)547	case ssaop.OpNeq64F:548		return rewriteValue_OpNeq64F(v)549	case ssaop.OpNeq8:550		return rewriteValue_OpNeq8(v)551	case ssaop.OpNeqB:552		return rewriteValue_OpNeqB(v)553	case ssaop.OpNeqPtr:554		return rewriteValue_OpNeqPtr(v)555	case ssaop.OpNilCheck:556		v.Op = ssaop.Op386LoweredNilCheck557		return true558	case ssaop.OpNot:559		return rewriteValue_OpNot(v)560	case ssaop.OpOffPtr:561		return rewriteValue_OpOffPtr(v)562	case ssaop.OpOr16:563		v.Op = ssaop.Op386ORL564		return true565	case ssaop.OpOr32:566		v.Op = ssaop.Op386ORL567		return true568	case ssaop.OpOr8:569		v.Op = ssaop.Op386ORL570		return true571	case ssaop.OpOrB:572		v.Op = ssaop.Op386ORL573		return true574	case ssaop.OpPanicBounds:575		v.Op = ssaop.Op386LoweredPanicBoundsRR576		return true577	case ssaop.OpPanicExtend:578		v.Op = ssaop.Op386LoweredPanicExtendRR579		return true580	case ssaop.OpRotateLeft16:581		v.Op = ssaop.Op386ROLW582		return true583	case ssaop.OpRotateLeft32:584		v.Op = ssaop.Op386ROLL585		return true586	case ssaop.OpRotateLeft8:587		v.Op = ssaop.Op386ROLB588		return true589	case ssaop.OpRound32F:590		v.Op = ssaop.OpCopy591		return true592	case ssaop.OpRound64F:593		v.Op = ssaop.OpCopy594		return true595	case ssaop.OpRsh16Ux16:596		return rewriteValue_OpRsh16Ux16(v)597	case ssaop.OpRsh16Ux32:598		return rewriteValue_OpRsh16Ux32(v)599	case ssaop.OpRsh16Ux64:600		return rewriteValue_OpRsh16Ux64(v)601	case ssaop.OpRsh16Ux8:602		return rewriteValue_OpRsh16Ux8(v)603	case ssaop.OpRsh16x16:604		return rewriteValue_OpRsh16x16(v)605	case ssaop.OpRsh16x32:606		return rewriteValue_OpRsh16x32(v)607	case ssaop.OpRsh16x64:608		return rewriteValue_OpRsh16x64(v)609	case ssaop.OpRsh16x8:610		return rewriteValue_OpRsh16x8(v)611	case ssaop.OpRsh32Ux16:612		return rewriteValue_OpRsh32Ux16(v)613	case ssaop.OpRsh32Ux32:614		return rewriteValue_OpRsh32Ux32(v)615	case ssaop.OpRsh32Ux64:616		return rewriteValue_OpRsh32Ux64(v)617	case ssaop.OpRsh32Ux8:618		return rewriteValue_OpRsh32Ux8(v)619	case ssaop.OpRsh32x16:620		return rewriteValue_OpRsh32x16(v)621	case ssaop.OpRsh32x32:622		return rewriteValue_OpRsh32x32(v)623	case ssaop.OpRsh32x64:624		return rewriteValue_OpRsh32x64(v)625	case ssaop.OpRsh32x8:626		return rewriteValue_OpRsh32x8(v)627	case ssaop.OpRsh8Ux16:628		return rewriteValue_OpRsh8Ux16(v)629	case ssaop.OpRsh8Ux32:630		return rewriteValue_OpRsh8Ux32(v)631	case ssaop.OpRsh8Ux64:632		return rewriteValue_OpRsh8Ux64(v)633	case ssaop.OpRsh8Ux8:634		return rewriteValue_OpRsh8Ux8(v)635	case ssaop.OpRsh8x16:636		return rewriteValue_OpRsh8x16(v)637	case ssaop.OpRsh8x32:638		return rewriteValue_OpRsh8x32(v)639	case ssaop.OpRsh8x64:640		return rewriteValue_OpRsh8x64(v)641	case ssaop.OpRsh8x8:642		return rewriteValue_OpRsh8x8(v)643	case ssaop.OpSelect0:644		return rewriteValue_OpSelect0(v)645	case ssaop.OpSelect1:646		return rewriteValue_OpSelect1(v)647	case ssaop.OpSignExt16to32:648		v.Op = ssaop.Op386MOVWLSX649		return true650	case ssaop.OpSignExt8to16:651		v.Op = ssaop.Op386MOVBLSX652		return true653	case ssaop.OpSignExt8to32:654		v.Op = ssaop.Op386MOVBLSX655		return true656	case ssaop.OpSignmask:657		return rewriteValue_OpSignmask(v)658	case ssaop.OpSlicemask:659		return rewriteValue_OpSlicemask(v)660	case ssaop.OpSqrt:661		v.Op = ssaop.Op386SQRTSD662		return true663	case ssaop.OpSqrt32:664		v.Op = ssaop.Op386SQRTSS665		return true666	case ssaop.OpStaticCall:667		v.Op = ssaop.Op386CALLstatic668		return true669	case ssaop.OpStore:670		return rewriteValue_OpStore(v)671	case ssaop.OpSub16:672		v.Op = ssaop.Op386SUBL673		return true674	case ssaop.OpSub32:675		v.Op = ssaop.Op386SUBL676		return true677	case ssaop.OpSub32F:678		v.Op = ssaop.Op386SUBSS679		return true680	case ssaop.OpSub32carry:681		v.Op = ssaop.Op386SUBLcarry682		return true683	case ssaop.OpSub32withcarry:684		v.Op = ssaop.Op386SBBL685		return true686	case ssaop.OpSub64F:687		v.Op = ssaop.Op386SUBSD688		return true689	case ssaop.OpSub8:690		v.Op = ssaop.Op386SUBL691		return true692	case ssaop.OpSubPtr:693		v.Op = ssaop.Op386SUBL694		return true695	case ssaop.OpTailCall:696		v.Op = ssaop.Op386CALLtail697		return true698	case ssaop.OpTailCallInter:699		v.Op = ssaop.Op386CALLtailinter700		return true701	case ssaop.OpTrunc16to8:702		v.Op = ssaop.OpCopy703		return true704	case ssaop.OpTrunc32to16:705		v.Op = ssaop.OpCopy706		return true707	case ssaop.OpTrunc32to8:708		v.Op = ssaop.OpCopy709		return true710	case ssaop.OpWB:711		v.Op = ssaop.Op386LoweredWB712		return true713	case ssaop.OpXor16:714		v.Op = ssaop.Op386XORL715		return true716	case ssaop.OpXor32:717		v.Op = ssaop.Op386XORL718		return true719	case ssaop.OpXor8:720		v.Op = ssaop.Op386XORL721		return true722	case ssaop.OpZero:723		return rewriteValue_OpZero(v)724	case ssaop.OpZeroExt16to32:725		v.Op = ssaop.Op386MOVWLZX726		return true727	case ssaop.OpZeroExt8to16:728		v.Op = ssaop.Op386MOVBLZX729		return true730	case ssaop.OpZeroExt8to32:731		v.Op = ssaop.Op386MOVBLZX732		return true733	case ssaop.OpZeromask:734		return rewriteValue_OpZeromask(v)735	}736	return false737}738func rewriteValue_Op386ADCL(v *ssa.Value) bool {739	v_2 := v.Args[2]740	v_1 := v.Args[1]741	v_0 := v.Args[0]742	// match: (ADCL x (MOVLconst [c]) f)743	// result: (ADCLconst [c] x f)744	for {745		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {746			x := v_0747			if v_1.Op != ssaop.Op386MOVLconst {748				continue749			}750			c := ssa.AuxIntToInt32(v_1.AuxInt)751			f := v_2752			v.Reset(ssaop.Op386ADCLconst)753			v.AuxInt = ssa.Int32ToAuxInt(c)754			v.AddArg2(x, f)755			return true756		}757		break758	}759	return false760}761func rewriteValue_Op386ADDL(v *ssa.Value) bool {762	v_1 := v.Args[1]763	v_0 := v.Args[0]764	// match: (ADDL x (MOVLconst <t> [c]))765	// cond: !t.IsPtr()766	// result: (ADDLconst [c] x)767	for {768		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {769			x := v_0770			if v_1.Op != ssaop.Op386MOVLconst {771				continue772			}773			t := v_1.Type774			c := ssa.AuxIntToInt32(v_1.AuxInt)775			if !(!t.IsPtr()) {776				continue777			}778			v.Reset(ssaop.Op386ADDLconst)779			v.AuxInt = ssa.Int32ToAuxInt(c)780			v.AddArg(x)781			return true782		}783		break784	}785	// match: (ADDL x (SHLLconst [3] y))786	// result: (LEAL8 x y)787	for {788		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {789			x := v_0790			if v_1.Op != ssaop.Op386SHLLconst || ssa.AuxIntToInt32(v_1.AuxInt) != 3 {791				continue792			}793			y := v_1.Args[0]794			v.Reset(ssaop.Op386LEAL8)795			v.AddArg2(x, y)796			return true797		}798		break799	}800	// match: (ADDL x (SHLLconst [2] y))801	// result: (LEAL4 x y)802	for {803		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {804			x := v_0805			if v_1.Op != ssaop.Op386SHLLconst || ssa.AuxIntToInt32(v_1.AuxInt) != 2 {806				continue807			}808			y := v_1.Args[0]809			v.Reset(ssaop.Op386LEAL4)810			v.AddArg2(x, y)811			return true812		}813		break814	}815	// match: (ADDL x (SHLLconst [1] y))816	// result: (LEAL2 x y)817	for {818		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {819			x := v_0820			if v_1.Op != ssaop.Op386SHLLconst || ssa.AuxIntToInt32(v_1.AuxInt) != 1 {821				continue822			}823			y := v_1.Args[0]824			v.Reset(ssaop.Op386LEAL2)825			v.AddArg2(x, y)826			return true827		}828		break829	}830	// match: (ADDL x (ADDL y y))831	// result: (LEAL2 x y)832	for {833		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {834			x := v_0835			if v_1.Op != ssaop.Op386ADDL {836				continue837			}838			y := v_1.Args[1]839			if y != v_1.Args[0] {840				continue841			}842			v.Reset(ssaop.Op386LEAL2)843			v.AddArg2(x, y)844			return true845		}846		break847	}848	// match: (ADDL x (ADDL x y))849	// result: (LEAL2 y x)850	for {851		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {852			x := v_0853			if v_1.Op != ssaop.Op386ADDL {854				continue855			}856			_ = v_1.Args[1]857			v_1_0 := v_1.Args[0]858			v_1_1 := v_1.Args[1]859			for _i1 := 0; _i1 <= 1; _i1, v_1_0, v_1_1 = _i1+1, v_1_1, v_1_0 {860				if x != v_1_0 {861					continue862				}863				y := v_1_1864				v.Reset(ssaop.Op386LEAL2)865				v.AddArg2(y, x)866				return true867			}868		}869		break870	}871	// match: (ADDL (ADDLconst [c] x) y)872	// result: (LEAL1 [c] x y)873	for {874		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {875			if v_0.Op != ssaop.Op386ADDLconst {876				continue877			}878			c := ssa.AuxIntToInt32(v_0.AuxInt)879			x := v_0.Args[0]880			y := v_1881			v.Reset(ssaop.Op386LEAL1)882			v.AuxInt = ssa.Int32ToAuxInt(c)883			v.AddArg2(x, y)884			return true885		}886		break887	}888	// match: (ADDL x (LEAL [c] {s} y))889	// cond: x.Op != ssaop.OpSB && y.Op != ssaop.OpSB890	// result: (LEAL1 [c] {s} x y)891	for {892		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {893			x := v_0894			if v_1.Op != ssaop.Op386LEAL {895				continue896			}897			c := ssa.AuxIntToInt32(v_1.AuxInt)898			s := ssa.AuxToSym(v_1.Aux)899			y := v_1.Args[0]900			if !(x.Op != ssaop.OpSB && y.Op != ssaop.OpSB) {901				continue902			}903			v.Reset(ssaop.Op386LEAL1)904			v.AuxInt = ssa.Int32ToAuxInt(c)905			v.Aux = ssa.SymToAux(s)906			v.AddArg2(x, y)907			return true908		}909		break910	}911	// match: (ADDL x l:(MOVLload [off] {sym} ptr mem))912	// cond: ssa.CanMergeLoadClobber(v, l, x) && ssa.Clobber(l)913	// result: (ADDLload x [off] {sym} ptr mem)914	for {915		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {916			x := v_0917			l := v_1918			if l.Op != ssaop.Op386MOVLload {919				continue920			}921			off := ssa.AuxIntToInt32(l.AuxInt)922			sym := ssa.AuxToSym(l.Aux)923			mem := l.Args[1]924			ptr := l.Args[0]925			if !(ssa.CanMergeLoadClobber(v, l, x) && ssa.Clobber(l)) {926				continue927			}928			v.Reset(ssaop.Op386ADDLload)929			v.AuxInt = ssa.Int32ToAuxInt(off)930			v.Aux = ssa.SymToAux(sym)931			v.AddArg3(x, ptr, mem)932			return true933		}934		break935	}936	// match: (ADDL x (NEGL y))937	// result: (SUBL x y)938	for {939		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {940			x := v_0941			if v_1.Op != ssaop.Op386NEGL {942				continue943			}944			y := v_1.Args[0]945			v.Reset(ssaop.Op386SUBL)946			v.AddArg2(x, y)947			return true948		}949		break950	}951	return false952}953func rewriteValue_Op386ADDLcarry(v *ssa.Value) bool {954	v_1 := v.Args[1]955	v_0 := v.Args[0]956	// match: (ADDLcarry x (MOVLconst [c]))957	// result: (ADDLconstcarry [c] x)958	for {959		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {960			x := v_0961			if v_1.Op != ssaop.Op386MOVLconst {962				continue963			}964			c := ssa.AuxIntToInt32(v_1.AuxInt)965			v.Reset(ssaop.Op386ADDLconstcarry)966			v.AuxInt = ssa.Int32ToAuxInt(c)967			v.AddArg(x)968			return true969		}970		break971	}972	return false973}974func rewriteValue_Op386ADDLconst(v *ssa.Value) bool {975	v_0 := v.Args[0]976	// match: (ADDLconst [c] (ADDL x y))977	// result: (LEAL1 [c] x y)978	for {979		c := ssa.AuxIntToInt32(v.AuxInt)980		if v_0.Op != ssaop.Op386ADDL {981			break982		}983		y := v_0.Args[1]984		x := v_0.Args[0]985		v.Reset(ssaop.Op386LEAL1)986		v.AuxInt = ssa.Int32ToAuxInt(c)987		v.AddArg2(x, y)988		return true989	}990	// match: (ADDLconst [c] (LEAL [d] {s} x))991	// cond: ssa.Is32Bit(int64(c)+int64(d))992	// result: (LEAL [c+d] {s} x)993	for {994		c := ssa.AuxIntToInt32(v.AuxInt)995		if v_0.Op != ssaop.Op386LEAL {996			break997		}998		d := ssa.AuxIntToInt32(v_0.AuxInt)999		s := ssa.AuxToSym(v_0.Aux)1000		x := v_0.Args[0]1001		if !(ssa.Is32Bit(int64(c) + int64(d))) {1002			break1003		}1004		v.Reset(ssaop.Op386LEAL)1005		v.AuxInt = ssa.Int32ToAuxInt(c + d)1006		v.Aux = ssa.SymToAux(s)1007		v.AddArg(x)1008		return true1009	}1010	// match: (ADDLconst [c] x:(SP))1011	// result: (LEAL [c] x)1012	for {1013		c := ssa.AuxIntToInt32(v.AuxInt)1014		x := v_01015		if x.Op != ssaop.OpSP {1016			break1017		}1018		v.Reset(ssaop.Op386LEAL)1019		v.AuxInt = ssa.Int32ToAuxInt(c)1020		v.AddArg(x)1021		return true1022	}1023	// match: (ADDLconst [c] (LEAL1 [d] {s} x y))1024	// cond: ssa.Is32Bit(int64(c)+int64(d))1025	// result: (LEAL1 [c+d] {s} x y)1026	for {1027		c := ssa.AuxIntToInt32(v.AuxInt)1028		if v_0.Op != ssaop.Op386LEAL1 {1029			break1030		}1031		d := ssa.AuxIntToInt32(v_0.AuxInt)1032		s := ssa.AuxToSym(v_0.Aux)1033		y := v_0.Args[1]1034		x := v_0.Args[0]1035		if !(ssa.Is32Bit(int64(c) + int64(d))) {1036			break1037		}1038		v.Reset(ssaop.Op386LEAL1)1039		v.AuxInt = ssa.Int32ToAuxInt(c + d)1040		v.Aux = ssa.SymToAux(s)1041		v.AddArg2(x, y)1042		return true1043	}1044	// match: (ADDLconst [c] (LEAL2 [d] {s} x y))1045	// cond: ssa.Is32Bit(int64(c)+int64(d))1046	// result: (LEAL2 [c+d] {s} x y)1047	for {1048		c := ssa.AuxIntToInt32(v.AuxInt)1049		if v_0.Op != ssaop.Op386LEAL2 {1050			break1051		}1052		d := ssa.AuxIntToInt32(v_0.AuxInt)1053		s := ssa.AuxToSym(v_0.Aux)1054		y := v_0.Args[1]1055		x := v_0.Args[0]1056		if !(ssa.Is32Bit(int64(c) + int64(d))) {1057			break1058		}1059		v.Reset(ssaop.Op386LEAL2)1060		v.AuxInt = ssa.Int32ToAuxInt(c + d)1061		v.Aux = ssa.SymToAux(s)1062		v.AddArg2(x, y)1063		return true1064	}1065	// match: (ADDLconst [c] (LEAL4 [d] {s} x y))1066	// cond: ssa.Is32Bit(int64(c)+int64(d))1067	// result: (LEAL4 [c+d] {s} x y)1068	for {1069		c := ssa.AuxIntToInt32(v.AuxInt)1070		if v_0.Op != ssaop.Op386LEAL4 {1071			break1072		}1073		d := ssa.AuxIntToInt32(v_0.AuxInt)1074		s := ssa.AuxToSym(v_0.Aux)1075		y := v_0.Args[1]1076		x := v_0.Args[0]1077		if !(ssa.Is32Bit(int64(c) + int64(d))) {1078			break1079		}1080		v.Reset(ssaop.Op386LEAL4)1081		v.AuxInt = ssa.Int32ToAuxInt(c + d)1082		v.Aux = ssa.SymToAux(s)1083		v.AddArg2(x, y)1084		return true1085	}1086	// match: (ADDLconst [c] (LEAL8 [d] {s} x y))1087	// cond: ssa.Is32Bit(int64(c)+int64(d))1088	// result: (LEAL8 [c+d] {s} x y)1089	for {1090		c := ssa.AuxIntToInt32(v.AuxInt)1091		if v_0.Op != ssaop.Op386LEAL8 {1092			break1093		}1094		d := ssa.AuxIntToInt32(v_0.AuxInt)1095		s := ssa.AuxToSym(v_0.Aux)1096		y := v_0.Args[1]1097		x := v_0.Args[0]1098		if !(ssa.Is32Bit(int64(c) + int64(d))) {1099			break1100		}1101		v.Reset(ssaop.Op386LEAL8)1102		v.AuxInt = ssa.Int32ToAuxInt(c + d)1103		v.Aux = ssa.SymToAux(s)1104		v.AddArg2(x, y)1105		return true1106	}1107	// match: (ADDLconst [c] x)1108	// cond: c==01109	// result: x1110	for {1111		c := ssa.AuxIntToInt32(v.AuxInt)1112		x := v_01113		if !(c == 0) {1114			break1115		}1116		v.CopyOf(x)1117		return true1118	}1119	// match: (ADDLconst [c] (MOVLconst [d]))1120	// result: (MOVLconst [c+d])1121	for {1122		c := ssa.AuxIntToInt32(v.AuxInt)1123		if v_0.Op != ssaop.Op386MOVLconst {1124			break1125		}1126		d := ssa.AuxIntToInt32(v_0.AuxInt)1127		v.Reset(ssaop.Op386MOVLconst)1128		v.AuxInt = ssa.Int32ToAuxInt(c + d)1129		return true1130	}1131	// match: (ADDLconst [c] (ADDLconst [d] x))1132	// result: (ADDLconst [c+d] x)1133	for {1134		c := ssa.AuxIntToInt32(v.AuxInt)1135		if v_0.Op != ssaop.Op386ADDLconst {1136			break1137		}1138		d := ssa.AuxIntToInt32(v_0.AuxInt)1139		x := v_0.Args[0]1140		v.Reset(ssaop.Op386ADDLconst)1141		v.AuxInt = ssa.Int32ToAuxInt(c + d)1142		v.AddArg(x)1143		return true1144	}1145	return false1146}1147func rewriteValue_Op386ADDLconstmodify(v *ssa.Value) bool {1148	v_1 := v.Args[1]1149	v_0 := v.Args[0]1150	b := v.Block1151	config := b.Func.Config1152	// match: (ADDLconstmodify [valoff1] {sym} (ADDLconst [off2] base) mem)1153	// cond: valoff1.CanAdd32(off2)1154	// result: (ADDLconstmodify [valoff1.AddOffset32(off2)] {sym} base mem)1155	for {1156		valoff1 := ssa.AuxIntToValAndOff(v.AuxInt)1157		sym := ssa.AuxToSym(v.Aux)1158		if v_0.Op != ssaop.Op386ADDLconst {1159			break1160		}1161		off2 := ssa.AuxIntToInt32(v_0.AuxInt)1162		base := v_0.Args[0]1163		mem := v_11164		if !(valoff1.CanAdd32(off2)) {1165			break1166		}1167		v.Reset(ssaop.Op386ADDLconstmodify)1168		v.AuxInt = ssa.ValAndOffToAuxInt(valoff1.AddOffset32(off2))1169		v.Aux = ssa.SymToAux(sym)1170		v.AddArg2(base, mem)1171		return true1172	}1173	// match: (ADDLconstmodify [valoff1] {sym1} (LEAL [off2] {sym2} base) mem)1174	// cond: valoff1.CanAdd32(off2) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)1175	// result: (ADDLconstmodify [valoff1.AddOffset32(off2)] {ssa.MergeSym(sym1,sym2)} base mem)1176	for {1177		valoff1 := ssa.AuxIntToValAndOff(v.AuxInt)1178		sym1 := ssa.AuxToSym(v.Aux)1179		if v_0.Op != ssaop.Op386LEAL {1180			break1181		}1182		off2 := ssa.AuxIntToInt32(v_0.AuxInt)1183		sym2 := ssa.AuxToSym(v_0.Aux)1184		base := v_0.Args[0]1185		mem := v_11186		if !(valoff1.CanAdd32(off2) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)) {1187			break1188		}1189		v.Reset(ssaop.Op386ADDLconstmodify)1190		v.AuxInt = ssa.ValAndOffToAuxInt(valoff1.AddOffset32(off2))1191		v.Aux = ssa.SymToAux(ssa.MergeSym(sym1, sym2))1192		v.AddArg2(base, mem)1193		return true1194	}1195	return false1196}1197func rewriteValue_Op386ADDLload(v *ssa.Value) bool {1198	v_2 := v.Args[2]1199	v_1 := v.Args[1]1200	v_0 := v.Args[0]1201	b := v.Block1202	config := b.Func.Config1203	// match: (ADDLload [off1] {sym} val (ADDLconst [off2] base) mem)1204	// cond: ssa.Is32Bit(int64(off1)+int64(off2))1205	// result: (ADDLload [off1+off2] {sym} val base mem)1206	for {1207		off1 := ssa.AuxIntToInt32(v.AuxInt)1208		sym := ssa.AuxToSym(v.Aux)1209		val := v_01210		if v_1.Op != ssaop.Op386ADDLconst {1211			break1212		}1213		off2 := ssa.AuxIntToInt32(v_1.AuxInt)1214		base := v_1.Args[0]1215		mem := v_21216		if !(ssa.Is32Bit(int64(off1) + int64(off2))) {1217			break1218		}1219		v.Reset(ssaop.Op386ADDLload)1220		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1221		v.Aux = ssa.SymToAux(sym)1222		v.AddArg3(val, base, mem)1223		return true1224	}1225	// match: (ADDLload [off1] {sym1} val (LEAL [off2] {sym2} base) mem)1226	// cond: ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)1227	// result: (ADDLload [off1+off2] {ssa.MergeSym(sym1,sym2)} val base mem)1228	for {1229		off1 := ssa.AuxIntToInt32(v.AuxInt)1230		sym1 := ssa.AuxToSym(v.Aux)1231		val := v_01232		if v_1.Op != ssaop.Op386LEAL {1233			break1234		}1235		off2 := ssa.AuxIntToInt32(v_1.AuxInt)1236		sym2 := ssa.AuxToSym(v_1.Aux)1237		base := v_1.Args[0]1238		mem := v_21239		if !(ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)) {1240			break1241		}1242		v.Reset(ssaop.Op386ADDLload)1243		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1244		v.Aux = ssa.SymToAux(ssa.MergeSym(sym1, sym2))1245		v.AddArg3(val, base, mem)1246		return true1247	}1248	return false1249}1250func rewriteValue_Op386ADDLmodify(v *ssa.Value) bool {1251	v_2 := v.Args[2]1252	v_1 := v.Args[1]1253	v_0 := v.Args[0]1254	b := v.Block1255	config := b.Func.Config1256	// match: (ADDLmodify [off1] {sym} (ADDLconst [off2] base) val mem)1257	// cond: ssa.Is32Bit(int64(off1)+int64(off2))1258	// result: (ADDLmodify [off1+off2] {sym} base val mem)1259	for {1260		off1 := ssa.AuxIntToInt32(v.AuxInt)1261		sym := ssa.AuxToSym(v.Aux)1262		if v_0.Op != ssaop.Op386ADDLconst {1263			break1264		}1265		off2 := ssa.AuxIntToInt32(v_0.AuxInt)1266		base := v_0.Args[0]1267		val := v_11268		mem := v_21269		if !(ssa.Is32Bit(int64(off1) + int64(off2))) {1270			break1271		}1272		v.Reset(ssaop.Op386ADDLmodify)1273		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1274		v.Aux = ssa.SymToAux(sym)1275		v.AddArg3(base, val, mem)1276		return true1277	}1278	// match: (ADDLmodify [off1] {sym1} (LEAL [off2] {sym2} base) val mem)1279	// cond: ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)1280	// result: (ADDLmodify [off1+off2] {ssa.MergeSym(sym1,sym2)} base val mem)1281	for {1282		off1 := ssa.AuxIntToInt32(v.AuxInt)1283		sym1 := ssa.AuxToSym(v.Aux)1284		if v_0.Op != ssaop.Op386LEAL {1285			break1286		}1287		off2 := ssa.AuxIntToInt32(v_0.AuxInt)1288		sym2 := ssa.AuxToSym(v_0.Aux)1289		base := v_0.Args[0]1290		val := v_11291		mem := v_21292		if !(ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)) {1293			break1294		}1295		v.Reset(ssaop.Op386ADDLmodify)1296		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1297		v.Aux = ssa.SymToAux(ssa.MergeSym(sym1, sym2))1298		v.AddArg3(base, val, mem)1299		return true1300	}1301	return false1302}1303func rewriteValue_Op386ADDSD(v *ssa.Value) bool {1304	v_1 := v.Args[1]1305	v_0 := v.Args[0]1306	// match: (ADDSD x l:(MOVSDload [off] {sym} ptr mem))1307	// cond: ssa.CanMergeLoadClobber(v, l, x) && ssa.Clobber(l)1308	// result: (ADDSDload x [off] {sym} ptr mem)1309	for {1310		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1311			x := v_01312			l := v_11313			if l.Op != ssaop.Op386MOVSDload {1314				continue1315			}1316			off := ssa.AuxIntToInt32(l.AuxInt)1317			sym := ssa.AuxToSym(l.Aux)1318			mem := l.Args[1]1319			ptr := l.Args[0]1320			if !(ssa.CanMergeLoadClobber(v, l, x) && ssa.Clobber(l)) {1321				continue1322			}1323			v.Reset(ssaop.Op386ADDSDload)1324			v.AuxInt = ssa.Int32ToAuxInt(off)1325			v.Aux = ssa.SymToAux(sym)1326			v.AddArg3(x, ptr, mem)1327			return true1328		}1329		break1330	}1331	return false1332}1333func rewriteValue_Op386ADDSDload(v *ssa.Value) bool {1334	v_2 := v.Args[2]1335	v_1 := v.Args[1]1336	v_0 := v.Args[0]1337	b := v.Block1338	config := b.Func.Config1339	// match: (ADDSDload [off1] {sym} val (ADDLconst [off2] base) mem)1340	// cond: ssa.Is32Bit(int64(off1)+int64(off2))1341	// result: (ADDSDload [off1+off2] {sym} val base mem)1342	for {1343		off1 := ssa.AuxIntToInt32(v.AuxInt)1344		sym := ssa.AuxToSym(v.Aux)1345		val := v_01346		if v_1.Op != ssaop.Op386ADDLconst {1347			break1348		}1349		off2 := ssa.AuxIntToInt32(v_1.AuxInt)1350		base := v_1.Args[0]1351		mem := v_21352		if !(ssa.Is32Bit(int64(off1) + int64(off2))) {1353			break1354		}1355		v.Reset(ssaop.Op386ADDSDload)1356		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1357		v.Aux = ssa.SymToAux(sym)1358		v.AddArg3(val, base, mem)1359		return true1360	}1361	// match: (ADDSDload [off1] {sym1} val (LEAL [off2] {sym2} base) mem)1362	// cond: ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)1363	// result: (ADDSDload [off1+off2] {ssa.MergeSym(sym1,sym2)} val base mem)1364	for {1365		off1 := ssa.AuxIntToInt32(v.AuxInt)1366		sym1 := ssa.AuxToSym(v.Aux)1367		val := v_01368		if v_1.Op != ssaop.Op386LEAL {1369			break1370		}1371		off2 := ssa.AuxIntToInt32(v_1.AuxInt)1372		sym2 := ssa.AuxToSym(v_1.Aux)1373		base := v_1.Args[0]1374		mem := v_21375		if !(ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)) {1376			break1377		}1378		v.Reset(ssaop.Op386ADDSDload)1379		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1380		v.Aux = ssa.SymToAux(ssa.MergeSym(sym1, sym2))1381		v.AddArg3(val, base, mem)1382		return true1383	}1384	return false1385}1386func rewriteValue_Op386ADDSS(v *ssa.Value) bool {1387	v_1 := v.Args[1]1388	v_0 := v.Args[0]1389	// match: (ADDSS x l:(MOVSSload [off] {sym} ptr mem))1390	// cond: ssa.CanMergeLoadClobber(v, l, x) && ssa.Clobber(l)1391	// result: (ADDSSload x [off] {sym} ptr mem)1392	for {1393		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1394			x := v_01395			l := v_11396			if l.Op != ssaop.Op386MOVSSload {1397				continue1398			}1399			off := ssa.AuxIntToInt32(l.AuxInt)1400			sym := ssa.AuxToSym(l.Aux)1401			mem := l.Args[1]1402			ptr := l.Args[0]1403			if !(ssa.CanMergeLoadClobber(v, l, x) && ssa.Clobber(l)) {1404				continue1405			}1406			v.Reset(ssaop.Op386ADDSSload)1407			v.AuxInt = ssa.Int32ToAuxInt(off)1408			v.Aux = ssa.SymToAux(sym)1409			v.AddArg3(x, ptr, mem)1410			return true1411		}1412		break1413	}1414	return false1415}1416func rewriteValue_Op386ADDSSload(v *ssa.Value) bool {1417	v_2 := v.Args[2]1418	v_1 := v.Args[1]1419	v_0 := v.Args[0]1420	b := v.Block1421	config := b.Func.Config1422	// match: (ADDSSload [off1] {sym} val (ADDLconst [off2] base) mem)1423	// cond: ssa.Is32Bit(int64(off1)+int64(off2))1424	// result: (ADDSSload [off1+off2] {sym} val base mem)1425	for {1426		off1 := ssa.AuxIntToInt32(v.AuxInt)1427		sym := ssa.AuxToSym(v.Aux)1428		val := v_01429		if v_1.Op != ssaop.Op386ADDLconst {1430			break1431		}1432		off2 := ssa.AuxIntToInt32(v_1.AuxInt)1433		base := v_1.Args[0]1434		mem := v_21435		if !(ssa.Is32Bit(int64(off1) + int64(off2))) {1436			break1437		}1438		v.Reset(ssaop.Op386ADDSSload)1439		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1440		v.Aux = ssa.SymToAux(sym)1441		v.AddArg3(val, base, mem)1442		return true1443	}1444	// match: (ADDSSload [off1] {sym1} val (LEAL [off2] {sym2} base) mem)1445	// cond: ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)1446	// result: (ADDSSload [off1+off2] {ssa.MergeSym(sym1,sym2)} val base mem)1447	for {1448		off1 := ssa.AuxIntToInt32(v.AuxInt)1449		sym1 := ssa.AuxToSym(v.Aux)1450		val := v_01451		if v_1.Op != ssaop.Op386LEAL {1452			break1453		}1454		off2 := ssa.AuxIntToInt32(v_1.AuxInt)1455		sym2 := ssa.AuxToSym(v_1.Aux)1456		base := v_1.Args[0]1457		mem := v_21458		if !(ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)) {1459			break1460		}1461		v.Reset(ssaop.Op386ADDSSload)1462		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1463		v.Aux = ssa.SymToAux(ssa.MergeSym(sym1, sym2))1464		v.AddArg3(val, base, mem)1465		return true1466	}1467	return false1468}1469func rewriteValue_Op386ANDL(v *ssa.Value) bool {1470	v_1 := v.Args[1]1471	v_0 := v.Args[0]1472	// match: (ANDL x (MOVLconst [c]))1473	// result: (ANDLconst [c] x)1474	for {1475		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1476			x := v_01477			if v_1.Op != ssaop.Op386MOVLconst {1478				continue1479			}1480			c := ssa.AuxIntToInt32(v_1.AuxInt)1481			v.Reset(ssaop.Op386ANDLconst)1482			v.AuxInt = ssa.Int32ToAuxInt(c)1483			v.AddArg(x)1484			return true1485		}1486		break1487	}1488	// match: (ANDL x l:(MOVLload [off] {sym} ptr mem))1489	// cond: ssa.CanMergeLoadClobber(v, l, x) && ssa.Clobber(l)1490	// result: (ANDLload x [off] {sym} ptr mem)1491	for {1492		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1493			x := v_01494			l := v_11495			if l.Op != ssaop.Op386MOVLload {1496				continue1497			}1498			off := ssa.AuxIntToInt32(l.AuxInt)1499			sym := ssa.AuxToSym(l.Aux)1500			mem := l.Args[1]1501			ptr := l.Args[0]1502			if !(ssa.CanMergeLoadClobber(v, l, x) && ssa.Clobber(l)) {1503				continue1504			}1505			v.Reset(ssaop.Op386ANDLload)1506			v.AuxInt = ssa.Int32ToAuxInt(off)1507			v.Aux = ssa.SymToAux(sym)1508			v.AddArg3(x, ptr, mem)1509			return true1510		}1511		break1512	}1513	// match: (ANDL x x)1514	// result: x1515	for {1516		x := v_01517		if x != v_1 {1518			break1519		}1520		v.CopyOf(x)1521		return true1522	}1523	return false1524}1525func rewriteValue_Op386ANDLconst(v *ssa.Value) bool {1526	v_0 := v.Args[0]1527	// match: (ANDLconst [c] (ANDLconst [d] x))1528	// result: (ANDLconst [c & d] x)1529	for {1530		c := ssa.AuxIntToInt32(v.AuxInt)1531		if v_0.Op != ssaop.Op386ANDLconst {1532			break1533		}1534		d := ssa.AuxIntToInt32(v_0.AuxInt)1535		x := v_0.Args[0]1536		v.Reset(ssaop.Op386ANDLconst)1537		v.AuxInt = ssa.Int32ToAuxInt(c & d)1538		v.AddArg(x)1539		return true1540	}1541	// match: (ANDLconst [c] _)1542	// cond: c==01543	// result: (MOVLconst [0])1544	for {1545		c := ssa.AuxIntToInt32(v.AuxInt)1546		if !(c == 0) {1547			break1548		}1549		v.Reset(ssaop.Op386MOVLconst)1550		v.AuxInt = ssa.Int32ToAuxInt(0)1551		return true1552	}1553	// match: (ANDLconst [c] x)1554	// cond: c==-11555	// result: x1556	for {1557		c := ssa.AuxIntToInt32(v.AuxInt)1558		x := v_01559		if !(c == -1) {1560			break1561		}1562		v.CopyOf(x)1563		return true1564	}1565	// match: (ANDLconst [c] (MOVLconst [d]))1566	// result: (MOVLconst [c&d])1567	for {1568		c := ssa.AuxIntToInt32(v.AuxInt)1569		if v_0.Op != ssaop.Op386MOVLconst {1570			break1571		}1572		d := ssa.AuxIntToInt32(v_0.AuxInt)1573		v.Reset(ssaop.Op386MOVLconst)1574		v.AuxInt = ssa.Int32ToAuxInt(c & d)1575		return true1576	}1577	return false1578}1579func rewriteValue_Op386ANDLconstmodify(v *ssa.Value) bool {1580	v_1 := v.Args[1]1581	v_0 := v.Args[0]1582	b := v.Block1583	config := b.Func.Config1584	// match: (ANDLconstmodify [valoff1] {sym} (ADDLconst [off2] base) mem)1585	// cond: valoff1.CanAdd32(off2)1586	// result: (ANDLconstmodify [valoff1.AddOffset32(off2)] {sym} base mem)1587	for {1588		valoff1 := ssa.AuxIntToValAndOff(v.AuxInt)1589		sym := ssa.AuxToSym(v.Aux)1590		if v_0.Op != ssaop.Op386ADDLconst {1591			break1592		}1593		off2 := ssa.AuxIntToInt32(v_0.AuxInt)1594		base := v_0.Args[0]1595		mem := v_11596		if !(valoff1.CanAdd32(off2)) {1597			break1598		}1599		v.Reset(ssaop.Op386ANDLconstmodify)1600		v.AuxInt = ssa.ValAndOffToAuxInt(valoff1.AddOffset32(off2))1601		v.Aux = ssa.SymToAux(sym)1602		v.AddArg2(base, mem)1603		return true1604	}1605	// match: (ANDLconstmodify [valoff1] {sym1} (LEAL [off2] {sym2} base) mem)1606	// cond: valoff1.CanAdd32(off2) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)1607	// result: (ANDLconstmodify [valoff1.AddOffset32(off2)] {ssa.MergeSym(sym1,sym2)} base mem)1608	for {1609		valoff1 := ssa.AuxIntToValAndOff(v.AuxInt)1610		sym1 := ssa.AuxToSym(v.Aux)1611		if v_0.Op != ssaop.Op386LEAL {1612			break1613		}1614		off2 := ssa.AuxIntToInt32(v_0.AuxInt)1615		sym2 := ssa.AuxToSym(v_0.Aux)1616		base := v_0.Args[0]1617		mem := v_11618		if !(valoff1.CanAdd32(off2) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)) {1619			break1620		}1621		v.Reset(ssaop.Op386ANDLconstmodify)1622		v.AuxInt = ssa.ValAndOffToAuxInt(valoff1.AddOffset32(off2))1623		v.Aux = ssa.SymToAux(ssa.MergeSym(sym1, sym2))1624		v.AddArg2(base, mem)1625		return true1626	}1627	return false1628}1629func rewriteValue_Op386ANDLload(v *ssa.Value) bool {1630	v_2 := v.Args[2]1631	v_1 := v.Args[1]1632	v_0 := v.Args[0]1633	b := v.Block1634	config := b.Func.Config1635	// match: (ANDLload [off1] {sym} val (ADDLconst [off2] base) mem)1636	// cond: ssa.Is32Bit(int64(off1)+int64(off2))1637	// result: (ANDLload [off1+off2] {sym} val base mem)1638	for {1639		off1 := ssa.AuxIntToInt32(v.AuxInt)1640		sym := ssa.AuxToSym(v.Aux)1641		val := v_01642		if v_1.Op != ssaop.Op386ADDLconst {1643			break1644		}1645		off2 := ssa.AuxIntToInt32(v_1.AuxInt)1646		base := v_1.Args[0]1647		mem := v_21648		if !(ssa.Is32Bit(int64(off1) + int64(off2))) {1649			break1650		}1651		v.Reset(ssaop.Op386ANDLload)1652		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1653		v.Aux = ssa.SymToAux(sym)1654		v.AddArg3(val, base, mem)1655		return true1656	}1657	// match: (ANDLload [off1] {sym1} val (LEAL [off2] {sym2} base) mem)1658	// cond: ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)1659	// result: (ANDLload [off1+off2] {ssa.MergeSym(sym1,sym2)} val base mem)1660	for {1661		off1 := ssa.AuxIntToInt32(v.AuxInt)1662		sym1 := ssa.AuxToSym(v.Aux)1663		val := v_01664		if v_1.Op != ssaop.Op386LEAL {1665			break1666		}1667		off2 := ssa.AuxIntToInt32(v_1.AuxInt)1668		sym2 := ssa.AuxToSym(v_1.Aux)1669		base := v_1.Args[0]1670		mem := v_21671		if !(ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)) {1672			break1673		}1674		v.Reset(ssaop.Op386ANDLload)1675		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1676		v.Aux = ssa.SymToAux(ssa.MergeSym(sym1, sym2))1677		v.AddArg3(val, base, mem)1678		return true1679	}1680	return false1681}1682func rewriteValue_Op386ANDLmodify(v *ssa.Value) bool {1683	v_2 := v.Args[2]1684	v_1 := v.Args[1]1685	v_0 := v.Args[0]1686	b := v.Block1687	config := b.Func.Config1688	// match: (ANDLmodify [off1] {sym} (ADDLconst [off2] base) val mem)1689	// cond: ssa.Is32Bit(int64(off1)+int64(off2))1690	// result: (ANDLmodify [off1+off2] {sym} base val mem)1691	for {1692		off1 := ssa.AuxIntToInt32(v.AuxInt)1693		sym := ssa.AuxToSym(v.Aux)1694		if v_0.Op != ssaop.Op386ADDLconst {1695			break1696		}1697		off2 := ssa.AuxIntToInt32(v_0.AuxInt)1698		base := v_0.Args[0]1699		val := v_11700		mem := v_21701		if !(ssa.Is32Bit(int64(off1) + int64(off2))) {1702			break1703		}1704		v.Reset(ssaop.Op386ANDLmodify)1705		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1706		v.Aux = ssa.SymToAux(sym)1707		v.AddArg3(base, val, mem)1708		return true1709	}1710	// match: (ANDLmodify [off1] {sym1} (LEAL [off2] {sym2} base) val mem)1711	// cond: ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)1712	// result: (ANDLmodify [off1+off2] {ssa.MergeSym(sym1,sym2)} base val mem)1713	for {1714		off1 := ssa.AuxIntToInt32(v.AuxInt)1715		sym1 := ssa.AuxToSym(v.Aux)1716		if v_0.Op != ssaop.Op386LEAL {1717			break1718		}1719		off2 := ssa.AuxIntToInt32(v_0.AuxInt)1720		sym2 := ssa.AuxToSym(v_0.Aux)1721		base := v_0.Args[0]1722		val := v_11723		mem := v_21724		if !(ssa.Is32Bit(int64(off1)+int64(off2)) && ssa.CanMergeSym(sym1, sym2) && (base.Op != ssaop.OpSB || !config.Ctxt.Flag_shared)) {1725			break1726		}1727		v.Reset(ssaop.Op386ANDLmodify)1728		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1729		v.Aux = ssa.SymToAux(ssa.MergeSym(sym1, sym2))1730		v.AddArg3(base, val, mem)1731		return true1732	}1733	return false1734}1735func rewriteValue_Op386CMPB(v *ssa.Value) bool {1736	v_1 := v.Args[1]1737	v_0 := v.Args[0]1738	b := v.Block1739	// match: (CMPB x (MOVLconst [c]))1740	// result: (CMPBconst x [int8(c)])1741	for {1742		x := v_01743		if v_1.Op != ssaop.Op386MOVLconst {1744			break1745		}1746		c := ssa.AuxIntToInt32(v_1.AuxInt)1747		v.Reset(ssaop.Op386CMPBconst)1748		v.AuxInt = ssa.Int8ToAuxInt(int8(c))1749		v.AddArg(x)1750		return true1751	}1752	// match: (CMPB (MOVLconst [c]) x)1753	// result: (InvertFlags (CMPBconst x [int8(c)]))1754	for {1755		if v_0.Op != ssaop.Op386MOVLconst {1756			break1757		}1758		c := ssa.AuxIntToInt32(v_0.AuxInt)1759		x := v_11760		v.Reset(ssaop.Op386InvertFlags)1761		v0 := b.NewValue0(v.Pos, ssaop.Op386CMPBconst, types.TypeFlags)1762		v0.AuxInt = ssa.Int8ToAuxInt(int8(c))1763		v0.AddArg(x)1764		v.AddArg(v0)1765		return true1766	}1767	// match: (CMPB x y)1768	// cond: ssa.CanonLessThan(x,y)1769	// result: (InvertFlags (CMPB y x))1770	for {1771		x := v_01772		y := v_11773		if !(ssa.CanonLessThan(x, y)) {1774			break1775		}1776		v.Reset(ssaop.Op386InvertFlags)1777		v0 := b.NewValue0(v.Pos, ssaop.Op386CMPB, types.TypeFlags)1778		v0.AddArg2(y, x)1779		v.AddArg(v0)1780		return true1781	}1782	// match: (CMPB l:(MOVBload {sym} [off] ptr mem) x)1783	// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)1784	// result: (CMPBload {sym} [off] ptr x mem)1785	for {1786		l := v_01787		if l.Op != ssaop.Op386MOVBload {1788			break1789		}1790		off := ssa.AuxIntToInt32(l.AuxInt)1791		sym := ssa.AuxToSym(l.Aux)1792		mem := l.Args[1]1793		ptr := l.Args[0]1794		x := v_11795		if !(ssa.CanMergeLoad(v, l) && ssa.Clobber(l)) {1796			break1797		}1798		v.Reset(ssaop.Op386CMPBload)1799		v.AuxInt = ssa.Int32ToAuxInt(off)1800		v.Aux = ssa.SymToAux(sym)1801		v.AddArg3(ptr, x, mem)1802		return true1803	}1804	// match: (CMPB x l:(MOVBload {sym} [off] ptr mem))1805	// cond: ssa.CanMergeLoad(v, l) && ssa.Clobber(l)1806	// result: (InvertFlags (CMPBload {sym} [off] ptr x mem))1807	for {1808		x := v_01809		l := v_11810		if l.Op != ssaop.Op386MOVBload {1811			break1812		}1813		off := ssa.AuxIntToInt32(l.AuxInt)1814		sym := ssa.AuxToSym(l.Aux)1815		mem := l.Args[1]1816		ptr := l.Args[0]1817		if !(ssa.CanMergeLoad(v, l) && ssa.Clobber(l)) {1818			break1819		}1820		v.Reset(ssaop.Op386InvertFlags)1821		v0 := b.NewValue0(l.Pos, ssaop.Op386CMPBload, types.TypeFlags)1822		v0.AuxInt = ssa.Int32ToAuxInt(off)1823		v0.Aux = ssa.SymToAux(sym)1824		v0.AddArg3(ptr, x, mem)1825		v.AddArg(v0)1826		return true1827	}1828	return false1829}1830func rewriteValue_Op386CMPBconst(v *ssa.Value) bool {1831	v_0 := v.Args[0]1832	b := v.Block1833	// match: (CMPBconst (MOVLconst [x]) [y])1834	// cond: int8(x)==y1835	// result: (FlagEQ)1836	for {1837		y := ssa.AuxIntToInt8(v.AuxInt)1838		if v_0.Op != ssaop.Op386MOVLconst {1839			break1840		}1841		x := ssa.AuxIntToInt32(v_0.AuxInt)1842		if !(int8(x) == y) {1843			break1844		}1845		v.Reset(ssaop.Op386FlagEQ)1846		return true1847	}1848	// match: (CMPBconst (MOVLconst [x]) [y])1849	// cond: int8(x)<y && uint8(x)<uint8(y)1850	// result: (FlagLT_ULT)1851	for {1852		y := ssa.AuxIntToInt8(v.AuxInt)1853		if v_0.Op != ssaop.Op386MOVLconst {1854			break1855		}1856		x := ssa.AuxIntToInt32(v_0.AuxInt)1857		if !(int8(x) < y && uint8(x) < uint8(y)) {1858			break1859		}1860		v.Reset(ssaop.Op386FlagLT_ULT)1861		return true1862	}1863	// match: (CMPBconst (MOVLconst [x]) [y])1864	// cond: int8(x)<y && uint8(x)>uint8(y)1865	// result: (FlagLT_UGT)1866	for {1867		y := ssa.AuxIntToInt8(v.AuxInt)1868		if v_0.Op != ssaop.Op386MOVLconst {1869			break1870		}1871		x := ssa.AuxIntToInt32(v_0.AuxInt)1872		if !(int8(x) < y && uint8(x) > uint8(y)) {1873			break1874		}1875		v.Reset(ssaop.Op386FlagLT_UGT)1876		return true1877	}1878	// match: (CMPBconst (MOVLconst [x]) [y])1879	// cond: int8(x)>y && uint8(x)<uint8(y)1880	// result: (FlagGT_ULT)1881	for {1882		y := ssa.AuxIntToInt8(v.AuxInt)1883		if v_0.Op != ssaop.Op386MOVLconst {1884			break1885		}1886		x := ssa.AuxIntToInt32(v_0.AuxInt)1887		if !(int8(x) > y && uint8(x) < uint8(y)) {1888			break1889		}1890		v.Reset(ssaop.Op386FlagGT_ULT)1891		return true1892	}1893	// match: (CMPBconst (MOVLconst [x]) [y])1894	// cond: int8(x)>y && uint8(x)>uint8(y)1895	// result: (FlagGT_UGT)1896	for {1897		y := ssa.AuxIntToInt8(v.AuxInt)1898		if v_0.Op != ssaop.Op386MOVLconst {1899			break1900		}1901		x := ssa.AuxIntToInt32(v_0.AuxInt)1902		if !(int8(x) > y && uint8(x) > uint8(y)) {1903			break1904		}1905		v.Reset(ssaop.Op386FlagGT_UGT)1906		return true1907	}1908	// match: (CMPBconst (ANDLconst _ [m]) [n])1909	// cond: 0 <= int8(m) && int8(m) < n1910	// result: (FlagLT_ULT)1911	for {1912		n := ssa.AuxIntToInt8(v.AuxInt)1913		if v_0.Op != ssaop.Op386ANDLconst {1914			break1915		}1916		m := ssa.AuxIntToInt32(v_0.AuxInt)1917		if !(0 <= int8(m) && int8(m) < n) {1918			break1919		}1920		v.Reset(ssaop.Op386FlagLT_ULT)1921		return true1922	}1923	// match: (CMPBconst l:(ANDL x y) [0])1924	// cond: l.Uses==11925	// result: (TESTB x y)1926	for {1927		if ssa.AuxIntToInt8(v.AuxInt) != 0 {1928			break1929		}1930		l := v_01931		if l.Op != ssaop.Op386ANDL {1932			break1933		}1934		y := l.Args[1]1935		x := l.Args[0]1936		if !(l.Uses == 1) {1937			break1938		}1939		v.Reset(ssaop.Op386TESTB)1940		v.AddArg2(x, y)1941		return true1942	}1943	// match: (CMPBconst l:(ANDLconst [c] x) [0])1944	// cond: l.Uses==11945	// result: (TESTBconst [int8(c)] x)1946	for {1947		if ssa.AuxIntToInt8(v.AuxInt) != 0 {1948			break1949		}1950		l := v_01951		if l.Op != ssaop.Op386ANDLconst {1952			break1953		}1954		c := ssa.AuxIntToInt32(l.AuxInt)1955		x := l.Args[0]1956		if !(l.Uses == 1) {1957			break1958		}1959		v.Reset(ssaop.Op386TESTBconst)1960		v.AuxInt = ssa.Int8ToAuxInt(int8(c))1961		v.AddArg(x)1962		return true1963	}1964	// match: (CMPBconst x [0])1965	// result: (TESTB x x)1966	for {1967		if ssa.AuxIntToInt8(v.AuxInt) != 0 {1968			break1969		}1970		x := v_01971		v.Reset(ssaop.Op386TESTB)1972		v.AddArg2(x, x)1973		return true1974	}1975	// match: (CMPBconst l:(MOVBload {sym} [off] ptr mem) [c])1976	// cond: l.Uses == 1 && ssa.Clobber(l)1977	// result: @l.Block (CMPBconstload {sym} [ssa.MakeValAndOff(int32(c),off)] ptr mem)1978	for {1979		c := ssa.AuxIntToInt8(v.AuxInt)1980		l := v_01981		if l.Op != ssaop.Op386MOVBload {1982			break1983		}1984		off := ssa.AuxIntToInt32(l.AuxInt)1985		sym := ssa.AuxToSym(l.Aux)1986		mem := l.Args[1]1987		ptr := l.Args[0]1988		if !(l.Uses == 1 && ssa.Clobber(l)) {1989			break1990		}1991		b = l.Block1992		v0 := b.NewValue0(l.Pos, ssaop.Op386CMPBconstload, types.TypeFlags)1993		v.CopyOf(v0)1994		v0.AuxInt = ssa.ValAndOffToAuxInt(ssa.MakeValAndOff(int32(c), off))1995		v0.Aux = ssa.SymToAux(sym)1996		v0.AddArg2(ptr, mem)1997		return true1998	}1999	return false2000}