1// Code generated from _gen/ARM.rules using 'go generate'; DO NOT EDIT.23package arm45import "internal/buildcfg"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.OpARMADC:14		return rewriteValue_OpARMADC(v)15	case ssaop.OpARMADCconst:16		return rewriteValue_OpARMADCconst(v)17	case ssaop.OpARMADCshiftLL:18		return rewriteValue_OpARMADCshiftLL(v)19	case ssaop.OpARMADCshiftLLreg:20		return rewriteValue_OpARMADCshiftLLreg(v)21	case ssaop.OpARMADCshiftRA:22		return rewriteValue_OpARMADCshiftRA(v)23	case ssaop.OpARMADCshiftRAreg:24		return rewriteValue_OpARMADCshiftRAreg(v)25	case ssaop.OpARMADCshiftRL:26		return rewriteValue_OpARMADCshiftRL(v)27	case ssaop.OpARMADCshiftRLreg:28		return rewriteValue_OpARMADCshiftRLreg(v)29	case ssaop.OpARMADD:30		return rewriteValue_OpARMADD(v)31	case ssaop.OpARMADDD:32		return rewriteValue_OpARMADDD(v)33	case ssaop.OpARMADDF:34		return rewriteValue_OpARMADDF(v)35	case ssaop.OpARMADDS:36		return rewriteValue_OpARMADDS(v)37	case ssaop.OpARMADDSshiftLL:38		return rewriteValue_OpARMADDSshiftLL(v)39	case ssaop.OpARMADDSshiftLLreg:40		return rewriteValue_OpARMADDSshiftLLreg(v)41	case ssaop.OpARMADDSshiftRA:42		return rewriteValue_OpARMADDSshiftRA(v)43	case ssaop.OpARMADDSshiftRAreg:44		return rewriteValue_OpARMADDSshiftRAreg(v)45	case ssaop.OpARMADDSshiftRL:46		return rewriteValue_OpARMADDSshiftRL(v)47	case ssaop.OpARMADDSshiftRLreg:48		return rewriteValue_OpARMADDSshiftRLreg(v)49	case ssaop.OpARMADDconst:50		return rewriteValue_OpARMADDconst(v)51	case ssaop.OpARMADDshiftLL:52		return rewriteValue_OpARMADDshiftLL(v)53	case ssaop.OpARMADDshiftLLreg:54		return rewriteValue_OpARMADDshiftLLreg(v)55	case ssaop.OpARMADDshiftRA:56		return rewriteValue_OpARMADDshiftRA(v)57	case ssaop.OpARMADDshiftRAreg:58		return rewriteValue_OpARMADDshiftRAreg(v)59	case ssaop.OpARMADDshiftRL:60		return rewriteValue_OpARMADDshiftRL(v)61	case ssaop.OpARMADDshiftRLreg:62		return rewriteValue_OpARMADDshiftRLreg(v)63	case ssaop.OpARMAND:64		return rewriteValue_OpARMAND(v)65	case ssaop.OpARMANDconst:66		return rewriteValue_OpARMANDconst(v)67	case ssaop.OpARMANDshiftLL:68		return rewriteValue_OpARMANDshiftLL(v)69	case ssaop.OpARMANDshiftLLreg:70		return rewriteValue_OpARMANDshiftLLreg(v)71	case ssaop.OpARMANDshiftRA:72		return rewriteValue_OpARMANDshiftRA(v)73	case ssaop.OpARMANDshiftRAreg:74		return rewriteValue_OpARMANDshiftRAreg(v)75	case ssaop.OpARMANDshiftRL:76		return rewriteValue_OpARMANDshiftRL(v)77	case ssaop.OpARMANDshiftRLreg:78		return rewriteValue_OpARMANDshiftRLreg(v)79	case ssaop.OpARMBFX:80		return rewriteValue_OpARMBFX(v)81	case ssaop.OpARMBFXU:82		return rewriteValue_OpARMBFXU(v)83	case ssaop.OpARMBIC:84		return rewriteValue_OpARMBIC(v)85	case ssaop.OpARMBICconst:86		return rewriteValue_OpARMBICconst(v)87	case ssaop.OpARMBICshiftLL:88		return rewriteValue_OpARMBICshiftLL(v)89	case ssaop.OpARMBICshiftLLreg:90		return rewriteValue_OpARMBICshiftLLreg(v)91	case ssaop.OpARMBICshiftRA:92		return rewriteValue_OpARMBICshiftRA(v)93	case ssaop.OpARMBICshiftRAreg:94		return rewriteValue_OpARMBICshiftRAreg(v)95	case ssaop.OpARMBICshiftRL:96		return rewriteValue_OpARMBICshiftRL(v)97	case ssaop.OpARMBICshiftRLreg:98		return rewriteValue_OpARMBICshiftRLreg(v)99	case ssaop.OpARMCMN:100		return rewriteValue_OpARMCMN(v)101	case ssaop.OpARMCMNconst:102		return rewriteValue_OpARMCMNconst(v)103	case ssaop.OpARMCMNshiftLL:104		return rewriteValue_OpARMCMNshiftLL(v)105	case ssaop.OpARMCMNshiftLLreg:106		return rewriteValue_OpARMCMNshiftLLreg(v)107	case ssaop.OpARMCMNshiftRA:108		return rewriteValue_OpARMCMNshiftRA(v)109	case ssaop.OpARMCMNshiftRAreg:110		return rewriteValue_OpARMCMNshiftRAreg(v)111	case ssaop.OpARMCMNshiftRL:112		return rewriteValue_OpARMCMNshiftRL(v)113	case ssaop.OpARMCMNshiftRLreg:114		return rewriteValue_OpARMCMNshiftRLreg(v)115	case ssaop.OpARMCMOVWHSconst:116		return rewriteValue_OpARMCMOVWHSconst(v)117	case ssaop.OpARMCMOVWLSconst:118		return rewriteValue_OpARMCMOVWLSconst(v)119	case ssaop.OpARMCMP:120		return rewriteValue_OpARMCMP(v)121	case ssaop.OpARMCMPD:122		return rewriteValue_OpARMCMPD(v)123	case ssaop.OpARMCMPF:124		return rewriteValue_OpARMCMPF(v)125	case ssaop.OpARMCMPconst:126		return rewriteValue_OpARMCMPconst(v)127	case ssaop.OpARMCMPshiftLL:128		return rewriteValue_OpARMCMPshiftLL(v)129	case ssaop.OpARMCMPshiftLLreg:130		return rewriteValue_OpARMCMPshiftLLreg(v)131	case ssaop.OpARMCMPshiftRA:132		return rewriteValue_OpARMCMPshiftRA(v)133	case ssaop.OpARMCMPshiftRAreg:134		return rewriteValue_OpARMCMPshiftRAreg(v)135	case ssaop.OpARMCMPshiftRL:136		return rewriteValue_OpARMCMPshiftRL(v)137	case ssaop.OpARMCMPshiftRLreg:138		return rewriteValue_OpARMCMPshiftRLreg(v)139	case ssaop.OpARMEqual:140		return rewriteValue_OpARMEqual(v)141	case ssaop.OpARMGreaterEqual:142		return rewriteValue_OpARMGreaterEqual(v)143	case ssaop.OpARMGreaterEqualU:144		return rewriteValue_OpARMGreaterEqualU(v)145	case ssaop.OpARMGreaterThan:146		return rewriteValue_OpARMGreaterThan(v)147	case ssaop.OpARMGreaterThanU:148		return rewriteValue_OpARMGreaterThanU(v)149	case ssaop.OpARMLessEqual:150		return rewriteValue_OpARMLessEqual(v)151	case ssaop.OpARMLessEqualU:152		return rewriteValue_OpARMLessEqualU(v)153	case ssaop.OpARMLessThan:154		return rewriteValue_OpARMLessThan(v)155	case ssaop.OpARMLessThanU:156		return rewriteValue_OpARMLessThanU(v)157	case ssaop.OpARMLoweredPanicBoundsRC:158		return rewriteValue_OpARMLoweredPanicBoundsRC(v)159	case ssaop.OpARMLoweredPanicBoundsRR:160		return rewriteValue_OpARMLoweredPanicBoundsRR(v)161	case ssaop.OpARMLoweredPanicExtendRC:162		return rewriteValue_OpARMLoweredPanicExtendRC(v)163	case ssaop.OpARMLoweredPanicExtendRR:164		return rewriteValue_OpARMLoweredPanicExtendRR(v)165	case ssaop.OpARMMOVBUload:166		return rewriteValue_OpARMMOVBUload(v)167	case ssaop.OpARMMOVBUloadidx:168		return rewriteValue_OpARMMOVBUloadidx(v)169	case ssaop.OpARMMOVBUreg:170		return rewriteValue_OpARMMOVBUreg(v)171	case ssaop.OpARMMOVBload:172		return rewriteValue_OpARMMOVBload(v)173	case ssaop.OpARMMOVBloadidx:174		return rewriteValue_OpARMMOVBloadidx(v)175	case ssaop.OpARMMOVBreg:176		return rewriteValue_OpARMMOVBreg(v)177	case ssaop.OpARMMOVBstore:178		return rewriteValue_OpARMMOVBstore(v)179	case ssaop.OpARMMOVBstoreidx:180		return rewriteValue_OpARMMOVBstoreidx(v)181	case ssaop.OpARMMOVDload:182		return rewriteValue_OpARMMOVDload(v)183	case ssaop.OpARMMOVDstore:184		return rewriteValue_OpARMMOVDstore(v)185	case ssaop.OpARMMOVFload:186		return rewriteValue_OpARMMOVFload(v)187	case ssaop.OpARMMOVFstore:188		return rewriteValue_OpARMMOVFstore(v)189	case ssaop.OpARMMOVHUload:190		return rewriteValue_OpARMMOVHUload(v)191	case ssaop.OpARMMOVHUloadidx:192		return rewriteValue_OpARMMOVHUloadidx(v)193	case ssaop.OpARMMOVHUreg:194		return rewriteValue_OpARMMOVHUreg(v)195	case ssaop.OpARMMOVHload:196		return rewriteValue_OpARMMOVHload(v)197	case ssaop.OpARMMOVHloadidx:198		return rewriteValue_OpARMMOVHloadidx(v)199	case ssaop.OpARMMOVHreg:200		return rewriteValue_OpARMMOVHreg(v)201	case ssaop.OpARMMOVHstore:202		return rewriteValue_OpARMMOVHstore(v)203	case ssaop.OpARMMOVHstoreidx:204		return rewriteValue_OpARMMOVHstoreidx(v)205	case ssaop.OpARMMOVWload:206		return rewriteValue_OpARMMOVWload(v)207	case ssaop.OpARMMOVWloadidx:208		return rewriteValue_OpARMMOVWloadidx(v)209	case ssaop.OpARMMOVWloadshiftLL:210		return rewriteValue_OpARMMOVWloadshiftLL(v)211	case ssaop.OpARMMOVWloadshiftRA:212		return rewriteValue_OpARMMOVWloadshiftRA(v)213	case ssaop.OpARMMOVWloadshiftRL:214		return rewriteValue_OpARMMOVWloadshiftRL(v)215	case ssaop.OpARMMOVWnop:216		return rewriteValue_OpARMMOVWnop(v)217	case ssaop.OpARMMOVWreg:218		return rewriteValue_OpARMMOVWreg(v)219	case ssaop.OpARMMOVWstore:220		return rewriteValue_OpARMMOVWstore(v)221	case ssaop.OpARMMOVWstoreidx:222		return rewriteValue_OpARMMOVWstoreidx(v)223	case ssaop.OpARMMOVWstoreshiftLL:224		return rewriteValue_OpARMMOVWstoreshiftLL(v)225	case ssaop.OpARMMOVWstoreshiftRA:226		return rewriteValue_OpARMMOVWstoreshiftRA(v)227	case ssaop.OpARMMOVWstoreshiftRL:228		return rewriteValue_OpARMMOVWstoreshiftRL(v)229	case ssaop.OpARMMUL:230		return rewriteValue_OpARMMUL(v)231	case ssaop.OpARMMULA:232		return rewriteValue_OpARMMULA(v)233	case ssaop.OpARMMULD:234		return rewriteValue_OpARMMULD(v)235	case ssaop.OpARMMULF:236		return rewriteValue_OpARMMULF(v)237	case ssaop.OpARMMULS:238		return rewriteValue_OpARMMULS(v)239	case ssaop.OpARMMVN:240		return rewriteValue_OpARMMVN(v)241	case ssaop.OpARMMVNshiftLL:242		return rewriteValue_OpARMMVNshiftLL(v)243	case ssaop.OpARMMVNshiftLLreg:244		return rewriteValue_OpARMMVNshiftLLreg(v)245	case ssaop.OpARMMVNshiftRA:246		return rewriteValue_OpARMMVNshiftRA(v)247	case ssaop.OpARMMVNshiftRAreg:248		return rewriteValue_OpARMMVNshiftRAreg(v)249	case ssaop.OpARMMVNshiftRL:250		return rewriteValue_OpARMMVNshiftRL(v)251	case ssaop.OpARMMVNshiftRLreg:252		return rewriteValue_OpARMMVNshiftRLreg(v)253	case ssaop.OpARMNEGD:254		return rewriteValue_OpARMNEGD(v)255	case ssaop.OpARMNEGF:256		return rewriteValue_OpARMNEGF(v)257	case ssaop.OpARMNMULD:258		return rewriteValue_OpARMNMULD(v)259	case ssaop.OpARMNMULF:260		return rewriteValue_OpARMNMULF(v)261	case ssaop.OpARMNotEqual:262		return rewriteValue_OpARMNotEqual(v)263	case ssaop.OpARMOR:264		return rewriteValue_OpARMOR(v)265	case ssaop.OpARMORconst:266		return rewriteValue_OpARMORconst(v)267	case ssaop.OpARMORshiftLL:268		return rewriteValue_OpARMORshiftLL(v)269	case ssaop.OpARMORshiftLLreg:270		return rewriteValue_OpARMORshiftLLreg(v)271	case ssaop.OpARMORshiftRA:272		return rewriteValue_OpARMORshiftRA(v)273	case ssaop.OpARMORshiftRAreg:274		return rewriteValue_OpARMORshiftRAreg(v)275	case ssaop.OpARMORshiftRL:276		return rewriteValue_OpARMORshiftRL(v)277	case ssaop.OpARMORshiftRLreg:278		return rewriteValue_OpARMORshiftRLreg(v)279	case ssaop.OpARMRSB:280		return rewriteValue_OpARMRSB(v)281	case ssaop.OpARMRSBSshiftLL:282		return rewriteValue_OpARMRSBSshiftLL(v)283	case ssaop.OpARMRSBSshiftLLreg:284		return rewriteValue_OpARMRSBSshiftLLreg(v)285	case ssaop.OpARMRSBSshiftRA:286		return rewriteValue_OpARMRSBSshiftRA(v)287	case ssaop.OpARMRSBSshiftRAreg:288		return rewriteValue_OpARMRSBSshiftRAreg(v)289	case ssaop.OpARMRSBSshiftRL:290		return rewriteValue_OpARMRSBSshiftRL(v)291	case ssaop.OpARMRSBSshiftRLreg:292		return rewriteValue_OpARMRSBSshiftRLreg(v)293	case ssaop.OpARMRSBconst:294		return rewriteValue_OpARMRSBconst(v)295	case ssaop.OpARMRSBshiftLL:296		return rewriteValue_OpARMRSBshiftLL(v)297	case ssaop.OpARMRSBshiftLLreg:298		return rewriteValue_OpARMRSBshiftLLreg(v)299	case ssaop.OpARMRSBshiftRA:300		return rewriteValue_OpARMRSBshiftRA(v)301	case ssaop.OpARMRSBshiftRAreg:302		return rewriteValue_OpARMRSBshiftRAreg(v)303	case ssaop.OpARMRSBshiftRL:304		return rewriteValue_OpARMRSBshiftRL(v)305	case ssaop.OpARMRSBshiftRLreg:306		return rewriteValue_OpARMRSBshiftRLreg(v)307	case ssaop.OpARMRSCconst:308		return rewriteValue_OpARMRSCconst(v)309	case ssaop.OpARMRSCshiftLL:310		return rewriteValue_OpARMRSCshiftLL(v)311	case ssaop.OpARMRSCshiftLLreg:312		return rewriteValue_OpARMRSCshiftLLreg(v)313	case ssaop.OpARMRSCshiftRA:314		return rewriteValue_OpARMRSCshiftRA(v)315	case ssaop.OpARMRSCshiftRAreg:316		return rewriteValue_OpARMRSCshiftRAreg(v)317	case ssaop.OpARMRSCshiftRL:318		return rewriteValue_OpARMRSCshiftRL(v)319	case ssaop.OpARMRSCshiftRLreg:320		return rewriteValue_OpARMRSCshiftRLreg(v)321	case ssaop.OpARMSBC:322		return rewriteValue_OpARMSBC(v)323	case ssaop.OpARMSBCconst:324		return rewriteValue_OpARMSBCconst(v)325	case ssaop.OpARMSBCshiftLL:326		return rewriteValue_OpARMSBCshiftLL(v)327	case ssaop.OpARMSBCshiftLLreg:328		return rewriteValue_OpARMSBCshiftLLreg(v)329	case ssaop.OpARMSBCshiftRA:330		return rewriteValue_OpARMSBCshiftRA(v)331	case ssaop.OpARMSBCshiftRAreg:332		return rewriteValue_OpARMSBCshiftRAreg(v)333	case ssaop.OpARMSBCshiftRL:334		return rewriteValue_OpARMSBCshiftRL(v)335	case ssaop.OpARMSBCshiftRLreg:336		return rewriteValue_OpARMSBCshiftRLreg(v)337	case ssaop.OpARMSLL:338		return rewriteValue_OpARMSLL(v)339	case ssaop.OpARMSLLconst:340		return rewriteValue_OpARMSLLconst(v)341	case ssaop.OpARMSRA:342		return rewriteValue_OpARMSRA(v)343	case ssaop.OpARMSRAcond:344		return rewriteValue_OpARMSRAcond(v)345	case ssaop.OpARMSRAconst:346		return rewriteValue_OpARMSRAconst(v)347	case ssaop.OpARMSRL:348		return rewriteValue_OpARMSRL(v)349	case ssaop.OpARMSRLconst:350		return rewriteValue_OpARMSRLconst(v)351	case ssaop.OpARMSRR:352		return rewriteValue_OpARMSRR(v)353	case ssaop.OpARMSUB:354		return rewriteValue_OpARMSUB(v)355	case ssaop.OpARMSUBD:356		return rewriteValue_OpARMSUBD(v)357	case ssaop.OpARMSUBF:358		return rewriteValue_OpARMSUBF(v)359	case ssaop.OpARMSUBS:360		return rewriteValue_OpARMSUBS(v)361	case ssaop.OpARMSUBSshiftLL:362		return rewriteValue_OpARMSUBSshiftLL(v)363	case ssaop.OpARMSUBSshiftLLreg:364		return rewriteValue_OpARMSUBSshiftLLreg(v)365	case ssaop.OpARMSUBSshiftRA:366		return rewriteValue_OpARMSUBSshiftRA(v)367	case ssaop.OpARMSUBSshiftRAreg:368		return rewriteValue_OpARMSUBSshiftRAreg(v)369	case ssaop.OpARMSUBSshiftRL:370		return rewriteValue_OpARMSUBSshiftRL(v)371	case ssaop.OpARMSUBSshiftRLreg:372		return rewriteValue_OpARMSUBSshiftRLreg(v)373	case ssaop.OpARMSUBconst:374		return rewriteValue_OpARMSUBconst(v)375	case ssaop.OpARMSUBshiftLL:376		return rewriteValue_OpARMSUBshiftLL(v)377	case ssaop.OpARMSUBshiftLLreg:378		return rewriteValue_OpARMSUBshiftLLreg(v)379	case ssaop.OpARMSUBshiftRA:380		return rewriteValue_OpARMSUBshiftRA(v)381	case ssaop.OpARMSUBshiftRAreg:382		return rewriteValue_OpARMSUBshiftRAreg(v)383	case ssaop.OpARMSUBshiftRL:384		return rewriteValue_OpARMSUBshiftRL(v)385	case ssaop.OpARMSUBshiftRLreg:386		return rewriteValue_OpARMSUBshiftRLreg(v)387	case ssaop.OpARMTEQ:388		return rewriteValue_OpARMTEQ(v)389	case ssaop.OpARMTEQconst:390		return rewriteValue_OpARMTEQconst(v)391	case ssaop.OpARMTEQshiftLL:392		return rewriteValue_OpARMTEQshiftLL(v)393	case ssaop.OpARMTEQshiftLLreg:394		return rewriteValue_OpARMTEQshiftLLreg(v)395	case ssaop.OpARMTEQshiftRA:396		return rewriteValue_OpARMTEQshiftRA(v)397	case ssaop.OpARMTEQshiftRAreg:398		return rewriteValue_OpARMTEQshiftRAreg(v)399	case ssaop.OpARMTEQshiftRL:400		return rewriteValue_OpARMTEQshiftRL(v)401	case ssaop.OpARMTEQshiftRLreg:402		return rewriteValue_OpARMTEQshiftRLreg(v)403	case ssaop.OpARMTST:404		return rewriteValue_OpARMTST(v)405	case ssaop.OpARMTSTconst:406		return rewriteValue_OpARMTSTconst(v)407	case ssaop.OpARMTSTshiftLL:408		return rewriteValue_OpARMTSTshiftLL(v)409	case ssaop.OpARMTSTshiftLLreg:410		return rewriteValue_OpARMTSTshiftLLreg(v)411	case ssaop.OpARMTSTshiftRA:412		return rewriteValue_OpARMTSTshiftRA(v)413	case ssaop.OpARMTSTshiftRAreg:414		return rewriteValue_OpARMTSTshiftRAreg(v)415	case ssaop.OpARMTSTshiftRL:416		return rewriteValue_OpARMTSTshiftRL(v)417	case ssaop.OpARMTSTshiftRLreg:418		return rewriteValue_OpARMTSTshiftRLreg(v)419	case ssaop.OpARMXOR:420		return rewriteValue_OpARMXOR(v)421	case ssaop.OpARMXORconst:422		return rewriteValue_OpARMXORconst(v)423	case ssaop.OpARMXORshiftLL:424		return rewriteValue_OpARMXORshiftLL(v)425	case ssaop.OpARMXORshiftLLreg:426		return rewriteValue_OpARMXORshiftLLreg(v)427	case ssaop.OpARMXORshiftRA:428		return rewriteValue_OpARMXORshiftRA(v)429	case ssaop.OpARMXORshiftRAreg:430		return rewriteValue_OpARMXORshiftRAreg(v)431	case ssaop.OpARMXORshiftRL:432		return rewriteValue_OpARMXORshiftRL(v)433	case ssaop.OpARMXORshiftRLreg:434		return rewriteValue_OpARMXORshiftRLreg(v)435	case ssaop.OpARMXORshiftRR:436		return rewriteValue_OpARMXORshiftRR(v)437	case ssaop.OpAbs:438		v.Op = ssaop.OpARMABSD439		return true440	case ssaop.OpAdd16:441		v.Op = ssaop.OpARMADD442		return true443	case ssaop.OpAdd32:444		v.Op = ssaop.OpARMADD445		return true446	case ssaop.OpAdd32F:447		v.Op = ssaop.OpARMADDF448		return true449	case ssaop.OpAdd32carry:450		v.Op = ssaop.OpARMADDS451		return true452	case ssaop.OpAdd32carrywithcarry:453		v.Op = ssaop.OpARMADCS454		return true455	case ssaop.OpAdd32withcarry:456		v.Op = ssaop.OpARMADC457		return true458	case ssaop.OpAdd64F:459		v.Op = ssaop.OpARMADDD460		return true461	case ssaop.OpAdd8:462		v.Op = ssaop.OpARMADD463		return true464	case ssaop.OpAddPtr:465		v.Op = ssaop.OpARMADD466		return true467	case ssaop.OpAddr:468		return rewriteValue_OpAddr(v)469	case ssaop.OpAnd16:470		v.Op = ssaop.OpARMAND471		return true472	case ssaop.OpAnd32:473		v.Op = ssaop.OpARMAND474		return true475	case ssaop.OpAnd8:476		v.Op = ssaop.OpARMAND477		return true478	case ssaop.OpAndB:479		v.Op = ssaop.OpARMAND480		return true481	case ssaop.OpAvg32u:482		return rewriteValue_OpAvg32u(v)483	case ssaop.OpBitLen16:484		return rewriteValue_OpBitLen16(v)485	case ssaop.OpBitLen32:486		return rewriteValue_OpBitLen32(v)487	case ssaop.OpBitLen8:488		return rewriteValue_OpBitLen8(v)489	case ssaop.OpBswap32:490		return rewriteValue_OpBswap32(v)491	case ssaop.OpClosureCall:492		v.Op = ssaop.OpARMCALLclosure493		return true494	case ssaop.OpCom16:495		v.Op = ssaop.OpARMMVN496		return true497	case ssaop.OpCom32:498		v.Op = ssaop.OpARMMVN499		return true500	case ssaop.OpCom8:501		v.Op = ssaop.OpARMMVN502		return true503	case ssaop.OpConst16:504		return rewriteValue_OpConst16(v)505	case ssaop.OpConst32:506		return rewriteValue_OpConst32(v)507	case ssaop.OpConst32F:508		return rewriteValue_OpConst32F(v)509	case ssaop.OpConst64F:510		return rewriteValue_OpConst64F(v)511	case ssaop.OpConst8:512		return rewriteValue_OpConst8(v)513	case ssaop.OpConstBool:514		return rewriteValue_OpConstBool(v)515	case ssaop.OpConstNil:516		return rewriteValue_OpConstNil(v)517	case ssaop.OpCtz16:518		return rewriteValue_OpCtz16(v)519	case ssaop.OpCtz16NonZero:520		v.Op = ssaop.OpCtz32521		return true522	case ssaop.OpCtz32:523		return rewriteValue_OpCtz32(v)524	case ssaop.OpCtz32NonZero:525		v.Op = ssaop.OpCtz32526		return true527	case ssaop.OpCtz8:528		return rewriteValue_OpCtz8(v)529	case ssaop.OpCtz8NonZero:530		v.Op = ssaop.OpCtz32531		return true532	case ssaop.OpCvt32Fto32:533		v.Op = ssaop.OpARMMOVFW534		return true535	case ssaop.OpCvt32Fto32U:536		v.Op = ssaop.OpARMMOVFWU537		return true538	case ssaop.OpCvt32Fto64F:539		v.Op = ssaop.OpARMMOVFD540		return true541	case ssaop.OpCvt32Uto32F:542		v.Op = ssaop.OpARMMOVWUF543		return true544	case ssaop.OpCvt32Uto64F:545		v.Op = ssaop.OpARMMOVWUD546		return true547	case ssaop.OpCvt32to32F:548		v.Op = ssaop.OpARMMOVWF549		return true550	case ssaop.OpCvt32to64F:551		v.Op = ssaop.OpARMMOVWD552		return true553	case ssaop.OpCvt64Fto32:554		v.Op = ssaop.OpARMMOVDW555		return true556	case ssaop.OpCvt64Fto32F:557		v.Op = ssaop.OpARMMOVDF558		return true559	case ssaop.OpCvt64Fto32U:560		v.Op = ssaop.OpARMMOVDWU561		return true562	case ssaop.OpCvtBoolToUint8:563		v.Op = ssaop.OpCopy564		return true565	case ssaop.OpDiv16:566		return rewriteValue_OpDiv16(v)567	case ssaop.OpDiv16u:568		return rewriteValue_OpDiv16u(v)569	case ssaop.OpDiv32:570		return rewriteValue_OpDiv32(v)571	case ssaop.OpDiv32F:572		v.Op = ssaop.OpARMDIVF573		return true574	case ssaop.OpDiv32u:575		return rewriteValue_OpDiv32u(v)576	case ssaop.OpDiv64F:577		v.Op = ssaop.OpARMDIVD578		return true579	case ssaop.OpDiv8:580		return rewriteValue_OpDiv8(v)581	case ssaop.OpDiv8u:582		return rewriteValue_OpDiv8u(v)583	case ssaop.OpEq16:584		return rewriteValue_OpEq16(v)585	case ssaop.OpEq32:586		return rewriteValue_OpEq32(v)587	case ssaop.OpEq32F:588		return rewriteValue_OpEq32F(v)589	case ssaop.OpEq64F:590		return rewriteValue_OpEq64F(v)591	case ssaop.OpEq8:592		return rewriteValue_OpEq8(v)593	case ssaop.OpEqB:594		return rewriteValue_OpEqB(v)595	case ssaop.OpEqPtr:596		return rewriteValue_OpEqPtr(v)597	case ssaop.OpFMA:598		return rewriteValue_OpFMA(v)599	case ssaop.OpGetCallerPC:600		v.Op = ssaop.OpARMLoweredGetCallerPC601		return true602	case ssaop.OpGetCallerSP:603		v.Op = ssaop.OpARMLoweredGetCallerSP604		return true605	case ssaop.OpGetClosurePtr:606		v.Op = ssaop.OpARMLoweredGetClosurePtr607		return true608	case ssaop.OpHmul32:609		v.Op = ssaop.OpARMHMUL610		return true611	case ssaop.OpHmul32u:612		v.Op = ssaop.OpARMHMULU613		return true614	case ssaop.OpInterCall:615		v.Op = ssaop.OpARMCALLinter616		return true617	case ssaop.OpIsInBounds:618		return rewriteValue_OpIsInBounds(v)619	case ssaop.OpIsNonNil:620		return rewriteValue_OpIsNonNil(v)621	case ssaop.OpIsSliceInBounds:622		return rewriteValue_OpIsSliceInBounds(v)623	case ssaop.OpLeq16:624		return rewriteValue_OpLeq16(v)625	case ssaop.OpLeq16U:626		return rewriteValue_OpLeq16U(v)627	case ssaop.OpLeq32:628		return rewriteValue_OpLeq32(v)629	case ssaop.OpLeq32F:630		return rewriteValue_OpLeq32F(v)631	case ssaop.OpLeq32U:632		return rewriteValue_OpLeq32U(v)633	case ssaop.OpLeq64F:634		return rewriteValue_OpLeq64F(v)635	case ssaop.OpLeq8:636		return rewriteValue_OpLeq8(v)637	case ssaop.OpLeq8U:638		return rewriteValue_OpLeq8U(v)639	case ssaop.OpLess16:640		return rewriteValue_OpLess16(v)641	case ssaop.OpLess16U:642		return rewriteValue_OpLess16U(v)643	case ssaop.OpLess32:644		return rewriteValue_OpLess32(v)645	case ssaop.OpLess32F:646		return rewriteValue_OpLess32F(v)647	case ssaop.OpLess32U:648		return rewriteValue_OpLess32U(v)649	case ssaop.OpLess64F:650		return rewriteValue_OpLess64F(v)651	case ssaop.OpLess8:652		return rewriteValue_OpLess8(v)653	case ssaop.OpLess8U:654		return rewriteValue_OpLess8U(v)655	case ssaop.OpLoad:656		return rewriteValue_OpLoad(v)657	case ssaop.OpLocalAddr:658		return rewriteValue_OpLocalAddr(v)659	case ssaop.OpLsh16x16:660		return rewriteValue_OpLsh16x16(v)661	case ssaop.OpLsh16x32:662		return rewriteValue_OpLsh16x32(v)663	case ssaop.OpLsh16x64:664		return rewriteValue_OpLsh16x64(v)665	case ssaop.OpLsh16x8:666		return rewriteValue_OpLsh16x8(v)667	case ssaop.OpLsh32x16:668		return rewriteValue_OpLsh32x16(v)669	case ssaop.OpLsh32x32:670		return rewriteValue_OpLsh32x32(v)671	case ssaop.OpLsh32x64:672		return rewriteValue_OpLsh32x64(v)673	case ssaop.OpLsh32x8:674		return rewriteValue_OpLsh32x8(v)675	case ssaop.OpLsh8x16:676		return rewriteValue_OpLsh8x16(v)677	case ssaop.OpLsh8x32:678		return rewriteValue_OpLsh8x32(v)679	case ssaop.OpLsh8x64:680		return rewriteValue_OpLsh8x64(v)681	case ssaop.OpLsh8x8:682		return rewriteValue_OpLsh8x8(v)683	case ssaop.OpMod16:684		return rewriteValue_OpMod16(v)685	case ssaop.OpMod16u:686		return rewriteValue_OpMod16u(v)687	case ssaop.OpMod32:688		return rewriteValue_OpMod32(v)689	case ssaop.OpMod32u:690		return rewriteValue_OpMod32u(v)691	case ssaop.OpMod8:692		return rewriteValue_OpMod8(v)693	case ssaop.OpMod8u:694		return rewriteValue_OpMod8u(v)695	case ssaop.OpMove:696		return rewriteValue_OpMove(v)697	case ssaop.OpMul16:698		v.Op = ssaop.OpARMMUL699		return true700	case ssaop.OpMul32:701		v.Op = ssaop.OpARMMUL702		return true703	case ssaop.OpMul32F:704		v.Op = ssaop.OpARMMULF705		return true706	case ssaop.OpMul32uhilo:707		v.Op = ssaop.OpARMMULLU708		return true709	case ssaop.OpMul64F:710		v.Op = ssaop.OpARMMULD711		return true712	case ssaop.OpMul8:713		v.Op = ssaop.OpARMMUL714		return true715	case ssaop.OpNeg16:716		return rewriteValue_OpNeg16(v)717	case ssaop.OpNeg32:718		return rewriteValue_OpNeg32(v)719	case ssaop.OpNeg32F:720		v.Op = ssaop.OpARMNEGF721		return true722	case ssaop.OpNeg64F:723		v.Op = ssaop.OpARMNEGD724		return true725	case ssaop.OpNeg8:726		return rewriteValue_OpNeg8(v)727	case ssaop.OpNeq16:728		return rewriteValue_OpNeq16(v)729	case ssaop.OpNeq32:730		return rewriteValue_OpNeq32(v)731	case ssaop.OpNeq32F:732		return rewriteValue_OpNeq32F(v)733	case ssaop.OpNeq64F:734		return rewriteValue_OpNeq64F(v)735	case ssaop.OpNeq8:736		return rewriteValue_OpNeq8(v)737	case ssaop.OpNeqB:738		v.Op = ssaop.OpARMXOR739		return true740	case ssaop.OpNeqPtr:741		return rewriteValue_OpNeqPtr(v)742	case ssaop.OpNilCheck:743		v.Op = ssaop.OpARMLoweredNilCheck744		return true745	case ssaop.OpNot:746		return rewriteValue_OpNot(v)747	case ssaop.OpOffPtr:748		return rewriteValue_OpOffPtr(v)749	case ssaop.OpOr16:750		v.Op = ssaop.OpARMOR751		return true752	case ssaop.OpOr32:753		v.Op = ssaop.OpARMOR754		return true755	case ssaop.OpOr8:756		v.Op = ssaop.OpARMOR757		return true758	case ssaop.OpOrB:759		v.Op = ssaop.OpARMOR760		return true761	case ssaop.OpPanicBounds:762		v.Op = ssaop.OpARMLoweredPanicBoundsRR763		return true764	case ssaop.OpPanicExtend:765		v.Op = ssaop.OpARMLoweredPanicExtendRR766		return true767	case ssaop.OpRotateLeft16:768		return rewriteValue_OpRotateLeft16(v)769	case ssaop.OpRotateLeft32:770		return rewriteValue_OpRotateLeft32(v)771	case ssaop.OpRotateLeft8:772		return rewriteValue_OpRotateLeft8(v)773	case ssaop.OpRound32F:774		v.Op = ssaop.OpCopy775		return true776	case ssaop.OpRound64F:777		v.Op = ssaop.OpCopy778		return true779	case ssaop.OpRsh16Ux16:780		return rewriteValue_OpRsh16Ux16(v)781	case ssaop.OpRsh16Ux32:782		return rewriteValue_OpRsh16Ux32(v)783	case ssaop.OpRsh16Ux64:784		return rewriteValue_OpRsh16Ux64(v)785	case ssaop.OpRsh16Ux8:786		return rewriteValue_OpRsh16Ux8(v)787	case ssaop.OpRsh16x16:788		return rewriteValue_OpRsh16x16(v)789	case ssaop.OpRsh16x32:790		return rewriteValue_OpRsh16x32(v)791	case ssaop.OpRsh16x64:792		return rewriteValue_OpRsh16x64(v)793	case ssaop.OpRsh16x8:794		return rewriteValue_OpRsh16x8(v)795	case ssaop.OpRsh32Ux16:796		return rewriteValue_OpRsh32Ux16(v)797	case ssaop.OpRsh32Ux32:798		return rewriteValue_OpRsh32Ux32(v)799	case ssaop.OpRsh32Ux64:800		return rewriteValue_OpRsh32Ux64(v)801	case ssaop.OpRsh32Ux8:802		return rewriteValue_OpRsh32Ux8(v)803	case ssaop.OpRsh32x16:804		return rewriteValue_OpRsh32x16(v)805	case ssaop.OpRsh32x32:806		return rewriteValue_OpRsh32x32(v)807	case ssaop.OpRsh32x64:808		return rewriteValue_OpRsh32x64(v)809	case ssaop.OpRsh32x8:810		return rewriteValue_OpRsh32x8(v)811	case ssaop.OpRsh8Ux16:812		return rewriteValue_OpRsh8Ux16(v)813	case ssaop.OpRsh8Ux32:814		return rewriteValue_OpRsh8Ux32(v)815	case ssaop.OpRsh8Ux64:816		return rewriteValue_OpRsh8Ux64(v)817	case ssaop.OpRsh8Ux8:818		return rewriteValue_OpRsh8Ux8(v)819	case ssaop.OpRsh8x16:820		return rewriteValue_OpRsh8x16(v)821	case ssaop.OpRsh8x32:822		return rewriteValue_OpRsh8x32(v)823	case ssaop.OpRsh8x64:824		return rewriteValue_OpRsh8x64(v)825	case ssaop.OpRsh8x8:826		return rewriteValue_OpRsh8x8(v)827	case ssaop.OpSelect0:828		return rewriteValue_OpSelect0(v)829	case ssaop.OpSelect1:830		return rewriteValue_OpSelect1(v)831	case ssaop.OpSignExt16to32:832		v.Op = ssaop.OpARMMOVHreg833		return true834	case ssaop.OpSignExt8to16:835		v.Op = ssaop.OpARMMOVBreg836		return true837	case ssaop.OpSignExt8to32:838		v.Op = ssaop.OpARMMOVBreg839		return true840	case ssaop.OpSignmask:841		return rewriteValue_OpSignmask(v)842	case ssaop.OpSlicemask:843		return rewriteValue_OpSlicemask(v)844	case ssaop.OpSqrt:845		v.Op = ssaop.OpARMSQRTD846		return true847	case ssaop.OpSqrt32:848		v.Op = ssaop.OpARMSQRTF849		return true850	case ssaop.OpStaticCall:851		v.Op = ssaop.OpARMCALLstatic852		return true853	case ssaop.OpStore:854		return rewriteValue_OpStore(v)855	case ssaop.OpSub16:856		v.Op = ssaop.OpARMSUB857		return true858	case ssaop.OpSub32:859		v.Op = ssaop.OpARMSUB860		return true861	case ssaop.OpSub32F:862		v.Op = ssaop.OpARMSUBF863		return true864	case ssaop.OpSub32carry:865		v.Op = ssaop.OpARMSUBS866		return true867	case ssaop.OpSub32withcarry:868		v.Op = ssaop.OpARMSBC869		return true870	case ssaop.OpSub64F:871		v.Op = ssaop.OpARMSUBD872		return true873	case ssaop.OpSub8:874		v.Op = ssaop.OpARMSUB875		return true876	case ssaop.OpSubPtr:877		v.Op = ssaop.OpARMSUB878		return true879	case ssaop.OpTailCall:880		v.Op = ssaop.OpARMCALLtail881		return true882	case ssaop.OpTailCallInter:883		v.Op = ssaop.OpARMCALLtailinter884		return true885	case ssaop.OpTrunc16to8:886		v.Op = ssaop.OpCopy887		return true888	case ssaop.OpTrunc32to16:889		v.Op = ssaop.OpCopy890		return true891	case ssaop.OpTrunc32to8:892		v.Op = ssaop.OpCopy893		return true894	case ssaop.OpWB:895		v.Op = ssaop.OpARMLoweredWB896		return true897	case ssaop.OpXor16:898		v.Op = ssaop.OpARMXOR899		return true900	case ssaop.OpXor32:901		v.Op = ssaop.OpARMXOR902		return true903	case ssaop.OpXor8:904		v.Op = ssaop.OpARMXOR905		return true906	case ssaop.OpZero:907		return rewriteValue_OpZero(v)908	case ssaop.OpZeroExt16to32:909		v.Op = ssaop.OpARMMOVHUreg910		return true911	case ssaop.OpZeroExt8to16:912		v.Op = ssaop.OpARMMOVBUreg913		return true914	case ssaop.OpZeroExt8to32:915		v.Op = ssaop.OpARMMOVBUreg916		return true917	case ssaop.OpZeromask:918		return rewriteValue_OpZeromask(v)919	}920	return false921}922func rewriteValue_OpARMADC(v *ssa.Value) bool {923	v_2 := v.Args[2]924	v_1 := v.Args[1]925	v_0 := v.Args[0]926	// match: (ADC (MOVWconst [c]) x flags)927	// result: (ADCconst [c] x flags)928	for {929		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {930			if v_0.Op != ssaop.OpARMMOVWconst {931				continue932			}933			c := ssa.AuxIntToInt32(v_0.AuxInt)934			x := v_1935			flags := v_2936			v.Reset(ssaop.OpARMADCconst)937			v.AuxInt = ssa.Int32ToAuxInt(c)938			v.AddArg2(x, flags)939			return true940		}941		break942	}943	// match: (ADC x (SLLconst [c] y) flags)944	// result: (ADCshiftLL x y [c] flags)945	for {946		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {947			x := v_0948			if v_1.Op != ssaop.OpARMSLLconst {949				continue950			}951			c := ssa.AuxIntToInt32(v_1.AuxInt)952			y := v_1.Args[0]953			flags := v_2954			v.Reset(ssaop.OpARMADCshiftLL)955			v.AuxInt = ssa.Int32ToAuxInt(c)956			v.AddArg3(x, y, flags)957			return true958		}959		break960	}961	// match: (ADC x (SRLconst [c] y) flags)962	// result: (ADCshiftRL x y [c] flags)963	for {964		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {965			x := v_0966			if v_1.Op != ssaop.OpARMSRLconst {967				continue968			}969			c := ssa.AuxIntToInt32(v_1.AuxInt)970			y := v_1.Args[0]971			flags := v_2972			v.Reset(ssaop.OpARMADCshiftRL)973			v.AuxInt = ssa.Int32ToAuxInt(c)974			v.AddArg3(x, y, flags)975			return true976		}977		break978	}979	// match: (ADC x (SRAconst [c] y) flags)980	// result: (ADCshiftRA x y [c] flags)981	for {982		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {983			x := v_0984			if v_1.Op != ssaop.OpARMSRAconst {985				continue986			}987			c := ssa.AuxIntToInt32(v_1.AuxInt)988			y := v_1.Args[0]989			flags := v_2990			v.Reset(ssaop.OpARMADCshiftRA)991			v.AuxInt = ssa.Int32ToAuxInt(c)992			v.AddArg3(x, y, flags)993			return true994		}995		break996	}997	// match: (ADC x (SLL y z) flags)998	// result: (ADCshiftLLreg x y z flags)999	for {1000		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1001			x := v_01002			if v_1.Op != ssaop.OpARMSLL {1003				continue1004			}1005			z := v_1.Args[1]1006			y := v_1.Args[0]1007			flags := v_21008			v.Reset(ssaop.OpARMADCshiftLLreg)1009			v.AddArg4(x, y, z, flags)1010			return true1011		}1012		break1013	}1014	// match: (ADC x (SRL y z) flags)1015	// result: (ADCshiftRLreg x y z flags)1016	for {1017		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1018			x := v_01019			if v_1.Op != ssaop.OpARMSRL {1020				continue1021			}1022			z := v_1.Args[1]1023			y := v_1.Args[0]1024			flags := v_21025			v.Reset(ssaop.OpARMADCshiftRLreg)1026			v.AddArg4(x, y, z, flags)1027			return true1028		}1029		break1030	}1031	// match: (ADC x (SRA y z) flags)1032	// result: (ADCshiftRAreg x y z flags)1033	for {1034		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1035			x := v_01036			if v_1.Op != ssaop.OpARMSRA {1037				continue1038			}1039			z := v_1.Args[1]1040			y := v_1.Args[0]1041			flags := v_21042			v.Reset(ssaop.OpARMADCshiftRAreg)1043			v.AddArg4(x, y, z, flags)1044			return true1045		}1046		break1047	}1048	return false1049}1050func rewriteValue_OpARMADCconst(v *ssa.Value) bool {1051	v_1 := v.Args[1]1052	v_0 := v.Args[0]1053	// match: (ADCconst [c] (ADDconst [d] x) flags)1054	// result: (ADCconst [c+d] x flags)1055	for {1056		c := ssa.AuxIntToInt32(v.AuxInt)1057		if v_0.Op != ssaop.OpARMADDconst {1058			break1059		}1060		d := ssa.AuxIntToInt32(v_0.AuxInt)1061		x := v_0.Args[0]1062		flags := v_11063		v.Reset(ssaop.OpARMADCconst)1064		v.AuxInt = ssa.Int32ToAuxInt(c + d)1065		v.AddArg2(x, flags)1066		return true1067	}1068	// match: (ADCconst [c] (SUBconst [d] x) flags)1069	// result: (ADCconst [c-d] x flags)1070	for {1071		c := ssa.AuxIntToInt32(v.AuxInt)1072		if v_0.Op != ssaop.OpARMSUBconst {1073			break1074		}1075		d := ssa.AuxIntToInt32(v_0.AuxInt)1076		x := v_0.Args[0]1077		flags := v_11078		v.Reset(ssaop.OpARMADCconst)1079		v.AuxInt = ssa.Int32ToAuxInt(c - d)1080		v.AddArg2(x, flags)1081		return true1082	}1083	return false1084}1085func rewriteValue_OpARMADCshiftLL(v *ssa.Value) bool {1086	v_2 := v.Args[2]1087	v_1 := v.Args[1]1088	v_0 := v.Args[0]1089	b := v.Block1090	// match: (ADCshiftLL (MOVWconst [c]) x [d] flags)1091	// result: (ADCconst [c] (SLLconst <x.Type> x [d]) flags)1092	for {1093		d := ssa.AuxIntToInt32(v.AuxInt)1094		if v_0.Op != ssaop.OpARMMOVWconst {1095			break1096		}1097		c := ssa.AuxIntToInt32(v_0.AuxInt)1098		x := v_11099		flags := v_21100		v.Reset(ssaop.OpARMADCconst)1101		v.AuxInt = ssa.Int32ToAuxInt(c)1102		v0 := b.NewValue0(v.Pos, ssaop.OpARMSLLconst, x.Type)1103		v0.AuxInt = ssa.Int32ToAuxInt(d)1104		v0.AddArg(x)1105		v.AddArg2(v0, flags)1106		return true1107	}1108	// match: (ADCshiftLL x (MOVWconst [c]) [d] flags)1109	// result: (ADCconst x [c<<uint64(d)] flags)1110	for {1111		d := ssa.AuxIntToInt32(v.AuxInt)1112		x := v_01113		if v_1.Op != ssaop.OpARMMOVWconst {1114			break1115		}1116		c := ssa.AuxIntToInt32(v_1.AuxInt)1117		flags := v_21118		v.Reset(ssaop.OpARMADCconst)1119		v.AuxInt = ssa.Int32ToAuxInt(c << uint64(d))1120		v.AddArg2(x, flags)1121		return true1122	}1123	return false1124}1125func rewriteValue_OpARMADCshiftLLreg(v *ssa.Value) bool {1126	v_3 := v.Args[3]1127	v_2 := v.Args[2]1128	v_1 := v.Args[1]1129	v_0 := v.Args[0]1130	b := v.Block1131	// match: (ADCshiftLLreg (MOVWconst [c]) x y flags)1132	// result: (ADCconst [c] (SLL <x.Type> x y) flags)1133	for {1134		if v_0.Op != ssaop.OpARMMOVWconst {1135			break1136		}1137		c := ssa.AuxIntToInt32(v_0.AuxInt)1138		x := v_11139		y := v_21140		flags := v_31141		v.Reset(ssaop.OpARMADCconst)1142		v.AuxInt = ssa.Int32ToAuxInt(c)1143		v0 := b.NewValue0(v.Pos, ssaop.OpARMSLL, x.Type)1144		v0.AddArg2(x, y)1145		v.AddArg2(v0, flags)1146		return true1147	}1148	// match: (ADCshiftLLreg x y (MOVWconst [c]) flags)1149	// cond: 0 <= c && c < 321150	// result: (ADCshiftLL x y [c] flags)1151	for {1152		x := v_01153		y := v_11154		if v_2.Op != ssaop.OpARMMOVWconst {1155			break1156		}1157		c := ssa.AuxIntToInt32(v_2.AuxInt)1158		flags := v_31159		if !(0 <= c && c < 32) {1160			break1161		}1162		v.Reset(ssaop.OpARMADCshiftLL)1163		v.AuxInt = ssa.Int32ToAuxInt(c)1164		v.AddArg3(x, y, flags)1165		return true1166	}1167	return false1168}1169func rewriteValue_OpARMADCshiftRA(v *ssa.Value) bool {1170	v_2 := v.Args[2]1171	v_1 := v.Args[1]1172	v_0 := v.Args[0]1173	b := v.Block1174	// match: (ADCshiftRA (MOVWconst [c]) x [d] flags)1175	// result: (ADCconst [c] (SRAconst <x.Type> x [d]) flags)1176	for {1177		d := ssa.AuxIntToInt32(v.AuxInt)1178		if v_0.Op != ssaop.OpARMMOVWconst {1179			break1180		}1181		c := ssa.AuxIntToInt32(v_0.AuxInt)1182		x := v_11183		flags := v_21184		v.Reset(ssaop.OpARMADCconst)1185		v.AuxInt = ssa.Int32ToAuxInt(c)1186		v0 := b.NewValue0(v.Pos, ssaop.OpARMSRAconst, x.Type)1187		v0.AuxInt = ssa.Int32ToAuxInt(d)1188		v0.AddArg(x)1189		v.AddArg2(v0, flags)1190		return true1191	}1192	// match: (ADCshiftRA x (MOVWconst [c]) [d] flags)1193	// result: (ADCconst x [c>>uint64(d)] flags)1194	for {1195		d := ssa.AuxIntToInt32(v.AuxInt)1196		x := v_01197		if v_1.Op != ssaop.OpARMMOVWconst {1198			break1199		}1200		c := ssa.AuxIntToInt32(v_1.AuxInt)1201		flags := v_21202		v.Reset(ssaop.OpARMADCconst)1203		v.AuxInt = ssa.Int32ToAuxInt(c >> uint64(d))1204		v.AddArg2(x, flags)1205		return true1206	}1207	return false1208}1209func rewriteValue_OpARMADCshiftRAreg(v *ssa.Value) bool {1210	v_3 := v.Args[3]1211	v_2 := v.Args[2]1212	v_1 := v.Args[1]1213	v_0 := v.Args[0]1214	b := v.Block1215	// match: (ADCshiftRAreg (MOVWconst [c]) x y flags)1216	// result: (ADCconst [c] (SRA <x.Type> x y) flags)1217	for {1218		if v_0.Op != ssaop.OpARMMOVWconst {1219			break1220		}1221		c := ssa.AuxIntToInt32(v_0.AuxInt)1222		x := v_11223		y := v_21224		flags := v_31225		v.Reset(ssaop.OpARMADCconst)1226		v.AuxInt = ssa.Int32ToAuxInt(c)1227		v0 := b.NewValue0(v.Pos, ssaop.OpARMSRA, x.Type)1228		v0.AddArg2(x, y)1229		v.AddArg2(v0, flags)1230		return true1231	}1232	// match: (ADCshiftRAreg x y (MOVWconst [c]) flags)1233	// cond: 0 <= c && c < 321234	// result: (ADCshiftRA x y [c] flags)1235	for {1236		x := v_01237		y := v_11238		if v_2.Op != ssaop.OpARMMOVWconst {1239			break1240		}1241		c := ssa.AuxIntToInt32(v_2.AuxInt)1242		flags := v_31243		if !(0 <= c && c < 32) {1244			break1245		}1246		v.Reset(ssaop.OpARMADCshiftRA)1247		v.AuxInt = ssa.Int32ToAuxInt(c)1248		v.AddArg3(x, y, flags)1249		return true1250	}1251	return false1252}1253func rewriteValue_OpARMADCshiftRL(v *ssa.Value) bool {1254	v_2 := v.Args[2]1255	v_1 := v.Args[1]1256	v_0 := v.Args[0]1257	b := v.Block1258	// match: (ADCshiftRL (MOVWconst [c]) x [d] flags)1259	// result: (ADCconst [c] (SRLconst <x.Type> x [d]) flags)1260	for {1261		d := ssa.AuxIntToInt32(v.AuxInt)1262		if v_0.Op != ssaop.OpARMMOVWconst {1263			break1264		}1265		c := ssa.AuxIntToInt32(v_0.AuxInt)1266		x := v_11267		flags := v_21268		v.Reset(ssaop.OpARMADCconst)1269		v.AuxInt = ssa.Int32ToAuxInt(c)1270		v0 := b.NewValue0(v.Pos, ssaop.OpARMSRLconst, x.Type)1271		v0.AuxInt = ssa.Int32ToAuxInt(d)1272		v0.AddArg(x)1273		v.AddArg2(v0, flags)1274		return true1275	}1276	// match: (ADCshiftRL x (MOVWconst [c]) [d] flags)1277	// result: (ADCconst x [int32(uint32(c)>>uint64(d))] flags)1278	for {1279		d := ssa.AuxIntToInt32(v.AuxInt)1280		x := v_01281		if v_1.Op != ssaop.OpARMMOVWconst {1282			break1283		}1284		c := ssa.AuxIntToInt32(v_1.AuxInt)1285		flags := v_21286		v.Reset(ssaop.OpARMADCconst)1287		v.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) >> uint64(d)))1288		v.AddArg2(x, flags)1289		return true1290	}1291	return false1292}1293func rewriteValue_OpARMADCshiftRLreg(v *ssa.Value) bool {1294	v_3 := v.Args[3]1295	v_2 := v.Args[2]1296	v_1 := v.Args[1]1297	v_0 := v.Args[0]1298	b := v.Block1299	// match: (ADCshiftRLreg (MOVWconst [c]) x y flags)1300	// result: (ADCconst [c] (SRL <x.Type> x y) flags)1301	for {1302		if v_0.Op != ssaop.OpARMMOVWconst {1303			break1304		}1305		c := ssa.AuxIntToInt32(v_0.AuxInt)1306		x := v_11307		y := v_21308		flags := v_31309		v.Reset(ssaop.OpARMADCconst)1310		v.AuxInt = ssa.Int32ToAuxInt(c)1311		v0 := b.NewValue0(v.Pos, ssaop.OpARMSRL, x.Type)1312		v0.AddArg2(x, y)1313		v.AddArg2(v0, flags)1314		return true1315	}1316	// match: (ADCshiftRLreg x y (MOVWconst [c]) flags)1317	// cond: 0 <= c && c < 321318	// result: (ADCshiftRL x y [c] flags)1319	for {1320		x := v_01321		y := v_11322		if v_2.Op != ssaop.OpARMMOVWconst {1323			break1324		}1325		c := ssa.AuxIntToInt32(v_2.AuxInt)1326		flags := v_31327		if !(0 <= c && c < 32) {1328			break1329		}1330		v.Reset(ssaop.OpARMADCshiftRL)1331		v.AuxInt = ssa.Int32ToAuxInt(c)1332		v.AddArg3(x, y, flags)1333		return true1334	}1335	return false1336}1337func rewriteValue_OpARMADD(v *ssa.Value) bool {1338	v_1 := v.Args[1]1339	v_0 := v.Args[0]1340	b := v.Block1341	// match: (ADD x (MOVWconst <t> [c]))1342	// cond: !t.IsPtr()1343	// result: (ADDconst [c] x)1344	for {1345		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1346			x := v_01347			if v_1.Op != ssaop.OpARMMOVWconst {1348				continue1349			}1350			t := v_1.Type1351			c := ssa.AuxIntToInt32(v_1.AuxInt)1352			if !(!t.IsPtr()) {1353				continue1354			}1355			v.Reset(ssaop.OpARMADDconst)1356			v.AuxInt = ssa.Int32ToAuxInt(c)1357			v.AddArg(x)1358			return true1359		}1360		break1361	}1362	// match: (ADD x (SLLconst [c] y))1363	// result: (ADDshiftLL x y [c])1364	for {1365		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1366			x := v_01367			if v_1.Op != ssaop.OpARMSLLconst {1368				continue1369			}1370			c := ssa.AuxIntToInt32(v_1.AuxInt)1371			y := v_1.Args[0]1372			v.Reset(ssaop.OpARMADDshiftLL)1373			v.AuxInt = ssa.Int32ToAuxInt(c)1374			v.AddArg2(x, y)1375			return true1376		}1377		break1378	}1379	// match: (ADD x (SRLconst [c] y))1380	// result: (ADDshiftRL x y [c])1381	for {1382		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1383			x := v_01384			if v_1.Op != ssaop.OpARMSRLconst {1385				continue1386			}1387			c := ssa.AuxIntToInt32(v_1.AuxInt)1388			y := v_1.Args[0]1389			v.Reset(ssaop.OpARMADDshiftRL)1390			v.AuxInt = ssa.Int32ToAuxInt(c)1391			v.AddArg2(x, y)1392			return true1393		}1394		break1395	}1396	// match: (ADD x (SRAconst [c] y))1397	// result: (ADDshiftRA x y [c])1398	for {1399		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1400			x := v_01401			if v_1.Op != ssaop.OpARMSRAconst {1402				continue1403			}1404			c := ssa.AuxIntToInt32(v_1.AuxInt)1405			y := v_1.Args[0]1406			v.Reset(ssaop.OpARMADDshiftRA)1407			v.AuxInt = ssa.Int32ToAuxInt(c)1408			v.AddArg2(x, y)1409			return true1410		}1411		break1412	}1413	// match: (ADD x (SLL y z))1414	// result: (ADDshiftLLreg x y z)1415	for {1416		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1417			x := v_01418			if v_1.Op != ssaop.OpARMSLL {1419				continue1420			}1421			z := v_1.Args[1]1422			y := v_1.Args[0]1423			v.Reset(ssaop.OpARMADDshiftLLreg)1424			v.AddArg3(x, y, z)1425			return true1426		}1427		break1428	}1429	// match: (ADD x (SRL y z))1430	// result: (ADDshiftRLreg x y z)1431	for {1432		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1433			x := v_01434			if v_1.Op != ssaop.OpARMSRL {1435				continue1436			}1437			z := v_1.Args[1]1438			y := v_1.Args[0]1439			v.Reset(ssaop.OpARMADDshiftRLreg)1440			v.AddArg3(x, y, z)1441			return true1442		}1443		break1444	}1445	// match: (ADD x (SRA y z))1446	// result: (ADDshiftRAreg x y z)1447	for {1448		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1449			x := v_01450			if v_1.Op != ssaop.OpARMSRA {1451				continue1452			}1453			z := v_1.Args[1]1454			y := v_1.Args[0]1455			v.Reset(ssaop.OpARMADDshiftRAreg)1456			v.AddArg3(x, y, z)1457			return true1458		}1459		break1460	}1461	// match: (ADD x (RSBconst [0] y))1462	// result: (SUB x y)1463	for {1464		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1465			x := v_01466			if v_1.Op != ssaop.OpARMRSBconst || ssa.AuxIntToInt32(v_1.AuxInt) != 0 {1467				continue1468			}1469			y := v_1.Args[0]1470			v.Reset(ssaop.OpARMSUB)1471			v.AddArg2(x, y)1472			return true1473		}1474		break1475	}1476	// match: (ADD <t> (RSBconst [c] x) (RSBconst [d] y))1477	// result: (RSBconst [c+d] (ADD <t> x y))1478	for {1479		t := v.Type1480		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1481			if v_0.Op != ssaop.OpARMRSBconst {1482				continue1483			}1484			c := ssa.AuxIntToInt32(v_0.AuxInt)1485			x := v_0.Args[0]1486			if v_1.Op != ssaop.OpARMRSBconst {1487				continue1488			}1489			d := ssa.AuxIntToInt32(v_1.AuxInt)1490			y := v_1.Args[0]1491			v.Reset(ssaop.OpARMRSBconst)1492			v.AuxInt = ssa.Int32ToAuxInt(c + d)1493			v0 := b.NewValue0(v.Pos, ssaop.OpARMADD, t)1494			v0.AddArg2(x, y)1495			v.AddArg(v0)1496			return true1497		}1498		break1499	}1500	// match: (ADD (MUL x y) a)1501	// result: (MULA x y a)1502	for {1503		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1504			if v_0.Op != ssaop.OpARMMUL {1505				continue1506			}1507			y := v_0.Args[1]1508			x := v_0.Args[0]1509			a := v_11510			v.Reset(ssaop.OpARMMULA)1511			v.AddArg3(x, y, a)1512			return true1513		}1514		break1515	}1516	return false1517}1518func rewriteValue_OpARMADDD(v *ssa.Value) bool {1519	v_1 := v.Args[1]1520	v_0 := v.Args[0]1521	// match: (ADDD a (MULD x y))1522	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 61523	// result: (MULAD a x y)1524	for {1525		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1526			a := v_01527			if v_1.Op != ssaop.OpARMMULD {1528				continue1529			}1530			y := v_1.Args[1]1531			x := v_1.Args[0]1532			if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {1533				continue1534			}1535			v.Reset(ssaop.OpARMMULAD)1536			v.AddArg3(a, x, y)1537			return true1538		}1539		break1540	}1541	// match: (ADDD a (NMULD x y))1542	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 61543	// result: (MULSD a x y)1544	for {1545		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1546			a := v_01547			if v_1.Op != ssaop.OpARMNMULD {1548				continue1549			}1550			y := v_1.Args[1]1551			x := v_1.Args[0]1552			if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {1553				continue1554			}1555			v.Reset(ssaop.OpARMMULSD)1556			v.AddArg3(a, x, y)1557			return true1558		}1559		break1560	}1561	return false1562}1563func rewriteValue_OpARMADDF(v *ssa.Value) bool {1564	v_1 := v.Args[1]1565	v_0 := v.Args[0]1566	// match: (ADDF a (MULF x y))1567	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 61568	// result: (MULAF a x y)1569	for {1570		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1571			a := v_01572			if v_1.Op != ssaop.OpARMMULF {1573				continue1574			}1575			y := v_1.Args[1]1576			x := v_1.Args[0]1577			if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {1578				continue1579			}1580			v.Reset(ssaop.OpARMMULAF)1581			v.AddArg3(a, x, y)1582			return true1583		}1584		break1585	}1586	// match: (ADDF a (NMULF x y))1587	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 61588	// result: (MULSF a x y)1589	for {1590		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1591			a := v_01592			if v_1.Op != ssaop.OpARMNMULF {1593				continue1594			}1595			y := v_1.Args[1]1596			x := v_1.Args[0]1597			if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {1598				continue1599			}1600			v.Reset(ssaop.OpARMMULSF)1601			v.AddArg3(a, x, y)1602			return true1603		}1604		break1605	}1606	return false1607}1608func rewriteValue_OpARMADDS(v *ssa.Value) bool {1609	v_1 := v.Args[1]1610	v_0 := v.Args[0]1611	// match: (ADDS x (MOVWconst [c]))1612	// result: (ADDSconst [c] x)1613	for {1614		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1615			x := v_01616			if v_1.Op != ssaop.OpARMMOVWconst {1617				continue1618			}1619			c := ssa.AuxIntToInt32(v_1.AuxInt)1620			v.Reset(ssaop.OpARMADDSconst)1621			v.AuxInt = ssa.Int32ToAuxInt(c)1622			v.AddArg(x)1623			return true1624		}1625		break1626	}1627	// match: (ADDS x (SLLconst [c] y))1628	// result: (ADDSshiftLL x y [c])1629	for {1630		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1631			x := v_01632			if v_1.Op != ssaop.OpARMSLLconst {1633				continue1634			}1635			c := ssa.AuxIntToInt32(v_1.AuxInt)1636			y := v_1.Args[0]1637			v.Reset(ssaop.OpARMADDSshiftLL)1638			v.AuxInt = ssa.Int32ToAuxInt(c)1639			v.AddArg2(x, y)1640			return true1641		}1642		break1643	}1644	// match: (ADDS x (SRLconst [c] y))1645	// result: (ADDSshiftRL x y [c])1646	for {1647		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1648			x := v_01649			if v_1.Op != ssaop.OpARMSRLconst {1650				continue1651			}1652			c := ssa.AuxIntToInt32(v_1.AuxInt)1653			y := v_1.Args[0]1654			v.Reset(ssaop.OpARMADDSshiftRL)1655			v.AuxInt = ssa.Int32ToAuxInt(c)1656			v.AddArg2(x, y)1657			return true1658		}1659		break1660	}1661	// match: (ADDS x (SRAconst [c] y))1662	// result: (ADDSshiftRA x y [c])1663	for {1664		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1665			x := v_01666			if v_1.Op != ssaop.OpARMSRAconst {1667				continue1668			}1669			c := ssa.AuxIntToInt32(v_1.AuxInt)1670			y := v_1.Args[0]1671			v.Reset(ssaop.OpARMADDSshiftRA)1672			v.AuxInt = ssa.Int32ToAuxInt(c)1673			v.AddArg2(x, y)1674			return true1675		}1676		break1677	}1678	// match: (ADDS x (SLL y z))1679	// result: (ADDSshiftLLreg x y z)1680	for {1681		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1682			x := v_01683			if v_1.Op != ssaop.OpARMSLL {1684				continue1685			}1686			z := v_1.Args[1]1687			y := v_1.Args[0]1688			v.Reset(ssaop.OpARMADDSshiftLLreg)1689			v.AddArg3(x, y, z)1690			return true1691		}1692		break1693	}1694	// match: (ADDS x (SRL y z))1695	// result: (ADDSshiftRLreg x y z)1696	for {1697		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1698			x := v_01699			if v_1.Op != ssaop.OpARMSRL {1700				continue1701			}1702			z := v_1.Args[1]1703			y := v_1.Args[0]1704			v.Reset(ssaop.OpARMADDSshiftRLreg)1705			v.AddArg3(x, y, z)1706			return true1707		}1708		break1709	}1710	// match: (ADDS x (SRA y z))1711	// result: (ADDSshiftRAreg x y z)1712	for {1713		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {1714			x := v_01715			if v_1.Op != ssaop.OpARMSRA {1716				continue1717			}1718			z := v_1.Args[1]1719			y := v_1.Args[0]1720			v.Reset(ssaop.OpARMADDSshiftRAreg)1721			v.AddArg3(x, y, z)1722			return true1723		}1724		break1725	}1726	return false1727}1728func rewriteValue_OpARMADDSshiftLL(v *ssa.Value) bool {1729	v_1 := v.Args[1]1730	v_0 := v.Args[0]1731	b := v.Block1732	// match: (ADDSshiftLL (MOVWconst [c]) x [d])1733	// result: (ADDSconst [c] (SLLconst <x.Type> x [d]))1734	for {1735		d := ssa.AuxIntToInt32(v.AuxInt)1736		if v_0.Op != ssaop.OpARMMOVWconst {1737			break1738		}1739		c := ssa.AuxIntToInt32(v_0.AuxInt)1740		x := v_11741		v.Reset(ssaop.OpARMADDSconst)1742		v.AuxInt = ssa.Int32ToAuxInt(c)1743		v0 := b.NewValue0(v.Pos, ssaop.OpARMSLLconst, x.Type)1744		v0.AuxInt = ssa.Int32ToAuxInt(d)1745		v0.AddArg(x)1746		v.AddArg(v0)1747		return true1748	}1749	// match: (ADDSshiftLL x (MOVWconst [c]) [d])1750	// result: (ADDSconst x [c<<uint64(d)])1751	for {1752		d := ssa.AuxIntToInt32(v.AuxInt)1753		x := v_01754		if v_1.Op != ssaop.OpARMMOVWconst {1755			break1756		}1757		c := ssa.AuxIntToInt32(v_1.AuxInt)1758		v.Reset(ssaop.OpARMADDSconst)1759		v.AuxInt = ssa.Int32ToAuxInt(c << uint64(d))1760		v.AddArg(x)1761		return true1762	}1763	return false1764}1765func rewriteValue_OpARMADDSshiftLLreg(v *ssa.Value) bool {1766	v_2 := v.Args[2]1767	v_1 := v.Args[1]1768	v_0 := v.Args[0]1769	b := v.Block1770	// match: (ADDSshiftLLreg (MOVWconst [c]) x y)1771	// result: (ADDSconst [c] (SLL <x.Type> x y))1772	for {1773		if v_0.Op != ssaop.OpARMMOVWconst {1774			break1775		}1776		c := ssa.AuxIntToInt32(v_0.AuxInt)1777		x := v_11778		y := v_21779		v.Reset(ssaop.OpARMADDSconst)1780		v.AuxInt = ssa.Int32ToAuxInt(c)1781		v0 := b.NewValue0(v.Pos, ssaop.OpARMSLL, x.Type)1782		v0.AddArg2(x, y)1783		v.AddArg(v0)1784		return true1785	}1786	// match: (ADDSshiftLLreg x y (MOVWconst [c]))1787	// cond: 0 <= c && c < 321788	// result: (ADDSshiftLL x y [c])1789	for {1790		x := v_01791		y := v_11792		if v_2.Op != ssaop.OpARMMOVWconst {1793			break1794		}1795		c := ssa.AuxIntToInt32(v_2.AuxInt)1796		if !(0 <= c && c < 32) {1797			break1798		}1799		v.Reset(ssaop.OpARMADDSshiftLL)1800		v.AuxInt = ssa.Int32ToAuxInt(c)1801		v.AddArg2(x, y)1802		return true1803	}1804	return false1805}1806func rewriteValue_OpARMADDSshiftRA(v *ssa.Value) bool {1807	v_1 := v.Args[1]1808	v_0 := v.Args[0]1809	b := v.Block1810	// match: (ADDSshiftRA (MOVWconst [c]) x [d])1811	// result: (ADDSconst [c] (SRAconst <x.Type> x [d]))1812	for {1813		d := ssa.AuxIntToInt32(v.AuxInt)1814		if v_0.Op != ssaop.OpARMMOVWconst {1815			break1816		}1817		c := ssa.AuxIntToInt32(v_0.AuxInt)1818		x := v_11819		v.Reset(ssaop.OpARMADDSconst)1820		v.AuxInt = ssa.Int32ToAuxInt(c)1821		v0 := b.NewValue0(v.Pos, ssaop.OpARMSRAconst, x.Type)1822		v0.AuxInt = ssa.Int32ToAuxInt(d)1823		v0.AddArg(x)1824		v.AddArg(v0)1825		return true1826	}1827	// match: (ADDSshiftRA x (MOVWconst [c]) [d])1828	// result: (ADDSconst x [c>>uint64(d)])1829	for {1830		d := ssa.AuxIntToInt32(v.AuxInt)1831		x := v_01832		if v_1.Op != ssaop.OpARMMOVWconst {1833			break1834		}1835		c := ssa.AuxIntToInt32(v_1.AuxInt)1836		v.Reset(ssaop.OpARMADDSconst)1837		v.AuxInt = ssa.Int32ToAuxInt(c >> uint64(d))1838		v.AddArg(x)1839		return true1840	}1841	return false1842}1843func rewriteValue_OpARMADDSshiftRAreg(v *ssa.Value) bool {1844	v_2 := v.Args[2]1845	v_1 := v.Args[1]1846	v_0 := v.Args[0]1847	b := v.Block1848	// match: (ADDSshiftRAreg (MOVWconst [c]) x y)1849	// result: (ADDSconst [c] (SRA <x.Type> x y))1850	for {1851		if v_0.Op != ssaop.OpARMMOVWconst {1852			break1853		}1854		c := ssa.AuxIntToInt32(v_0.AuxInt)1855		x := v_11856		y := v_21857		v.Reset(ssaop.OpARMADDSconst)1858		v.AuxInt = ssa.Int32ToAuxInt(c)1859		v0 := b.NewValue0(v.Pos, ssaop.OpARMSRA, x.Type)1860		v0.AddArg2(x, y)1861		v.AddArg(v0)1862		return true1863	}1864	// match: (ADDSshiftRAreg x y (MOVWconst [c]))1865	// cond: 0 <= c && c < 321866	// result: (ADDSshiftRA x y [c])1867	for {1868		x := v_01869		y := v_11870		if v_2.Op != ssaop.OpARMMOVWconst {1871			break1872		}1873		c := ssa.AuxIntToInt32(v_2.AuxInt)1874		if !(0 <= c && c < 32) {1875			break1876		}1877		v.Reset(ssaop.OpARMADDSshiftRA)1878		v.AuxInt = ssa.Int32ToAuxInt(c)1879		v.AddArg2(x, y)1880		return true1881	}1882	return false1883}1884func rewriteValue_OpARMADDSshiftRL(v *ssa.Value) bool {1885	v_1 := v.Args[1]1886	v_0 := v.Args[0]1887	b := v.Block1888	// match: (ADDSshiftRL (MOVWconst [c]) x [d])1889	// result: (ADDSconst [c] (SRLconst <x.Type> x [d]))1890	for {1891		d := ssa.AuxIntToInt32(v.AuxInt)1892		if v_0.Op != ssaop.OpARMMOVWconst {1893			break1894		}1895		c := ssa.AuxIntToInt32(v_0.AuxInt)1896		x := v_11897		v.Reset(ssaop.OpARMADDSconst)1898		v.AuxInt = ssa.Int32ToAuxInt(c)1899		v0 := b.NewValue0(v.Pos, ssaop.OpARMSRLconst, x.Type)1900		v0.AuxInt = ssa.Int32ToAuxInt(d)1901		v0.AddArg(x)1902		v.AddArg(v0)1903		return true1904	}1905	// match: (ADDSshiftRL x (MOVWconst [c]) [d])1906	// result: (ADDSconst x [int32(uint32(c)>>uint64(d))])1907	for {1908		d := ssa.AuxIntToInt32(v.AuxInt)1909		x := v_01910		if v_1.Op != ssaop.OpARMMOVWconst {1911			break1912		}1913		c := ssa.AuxIntToInt32(v_1.AuxInt)1914		v.Reset(ssaop.OpARMADDSconst)1915		v.AuxInt = ssa.Int32ToAuxInt(int32(uint32(c) >> uint64(d)))1916		v.AddArg(x)1917		return true1918	}1919	return false1920}1921func rewriteValue_OpARMADDSshiftRLreg(v *ssa.Value) bool {1922	v_2 := v.Args[2]1923	v_1 := v.Args[1]1924	v_0 := v.Args[0]1925	b := v.Block1926	// match: (ADDSshiftRLreg (MOVWconst [c]) x y)1927	// result: (ADDSconst [c] (SRL <x.Type> x y))1928	for {1929		if v_0.Op != ssaop.OpARMMOVWconst {1930			break1931		}1932		c := ssa.AuxIntToInt32(v_0.AuxInt)1933		x := v_11934		y := v_21935		v.Reset(ssaop.OpARMADDSconst)1936		v.AuxInt = ssa.Int32ToAuxInt(c)1937		v0 := b.NewValue0(v.Pos, ssaop.OpARMSRL, x.Type)1938		v0.AddArg2(x, y)1939		v.AddArg(v0)1940		return true1941	}1942	// match: (ADDSshiftRLreg x y (MOVWconst [c]))1943	// cond: 0 <= c && c < 321944	// result: (ADDSshiftRL x y [c])1945	for {1946		x := v_01947		y := v_11948		if v_2.Op != ssaop.OpARMMOVWconst {1949			break1950		}1951		c := ssa.AuxIntToInt32(v_2.AuxInt)1952		if !(0 <= c && c < 32) {1953			break1954		}1955		v.Reset(ssaop.OpARMADDSshiftRL)1956		v.AuxInt = ssa.Int32ToAuxInt(c)1957		v.AddArg2(x, y)1958		return true1959	}1960	return false1961}1962func rewriteValue_OpARMADDconst(v *ssa.Value) bool {1963	v_0 := v.Args[0]1964	// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))1965	// result: (MOVWaddr [off1+off2] {sym} ptr)1966	for {1967		off1 := ssa.AuxIntToInt32(v.AuxInt)1968		if v_0.Op != ssaop.OpARMMOVWaddr {1969			break1970		}1971		off2 := ssa.AuxIntToInt32(v_0.AuxInt)1972		sym := ssa.AuxToSym(v_0.Aux)1973		ptr := v_0.Args[0]1974		v.Reset(ssaop.OpARMMOVWaddr)1975		v.AuxInt = ssa.Int32ToAuxInt(off1 + off2)1976		v.Aux = ssa.SymToAux(sym)1977		v.AddArg(ptr)1978		return true1979	}1980	// match: (ADDconst [0] x)1981	// result: x1982	for {1983		if ssa.AuxIntToInt32(v.AuxInt) != 0 {1984			break1985		}1986		x := v_01987		v.CopyOf(x)1988		return true1989	}1990	// match: (ADDconst [c] x)1991	// cond: !isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))1992	// result: (SUBconst [-c] x)1993	for {1994		c := ssa.AuxIntToInt32(v.AuxInt)1995		x := v_01996		if !(!isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))) {1997			break1998		}1999		v.Reset(ssaop.OpARMSUBconst)2000		v.AuxInt = ssa.Int32ToAuxInt(-c)