Source file src/pkg/cmd/compile/internal/ssa/rewrite386.go
1
2
3
4 package ssa
5
6 import "fmt"
7 import "math"
8 import "cmd/internal/obj"
9 import "cmd/internal/objabi"
10 import "cmd/compile/internal/types"
11
12 var _ = fmt.Println
13 var _ = math.MinInt8
14 var _ = obj.ANOP
15 var _ = objabi.GOROOT
16 var _ = types.TypeMem
17
18 func rewriteValue386(v *Value) bool {
19 switch v.Op {
20 case Op386ADCL:
21 return rewriteValue386_Op386ADCL_0(v)
22 case Op386ADDL:
23 return rewriteValue386_Op386ADDL_0(v) || rewriteValue386_Op386ADDL_10(v) || rewriteValue386_Op386ADDL_20(v)
24 case Op386ADDLcarry:
25 return rewriteValue386_Op386ADDLcarry_0(v)
26 case Op386ADDLconst:
27 return rewriteValue386_Op386ADDLconst_0(v)
28 case Op386ADDLconstmodify:
29 return rewriteValue386_Op386ADDLconstmodify_0(v)
30 case Op386ADDLconstmodifyidx4:
31 return rewriteValue386_Op386ADDLconstmodifyidx4_0(v)
32 case Op386ADDLload:
33 return rewriteValue386_Op386ADDLload_0(v)
34 case Op386ADDLloadidx4:
35 return rewriteValue386_Op386ADDLloadidx4_0(v)
36 case Op386ADDLmodify:
37 return rewriteValue386_Op386ADDLmodify_0(v)
38 case Op386ADDLmodifyidx4:
39 return rewriteValue386_Op386ADDLmodifyidx4_0(v)
40 case Op386ADDSD:
41 return rewriteValue386_Op386ADDSD_0(v)
42 case Op386ADDSDload:
43 return rewriteValue386_Op386ADDSDload_0(v)
44 case Op386ADDSS:
45 return rewriteValue386_Op386ADDSS_0(v)
46 case Op386ADDSSload:
47 return rewriteValue386_Op386ADDSSload_0(v)
48 case Op386ANDL:
49 return rewriteValue386_Op386ANDL_0(v)
50 case Op386ANDLconst:
51 return rewriteValue386_Op386ANDLconst_0(v)
52 case Op386ANDLconstmodify:
53 return rewriteValue386_Op386ANDLconstmodify_0(v)
54 case Op386ANDLconstmodifyidx4:
55 return rewriteValue386_Op386ANDLconstmodifyidx4_0(v)
56 case Op386ANDLload:
57 return rewriteValue386_Op386ANDLload_0(v)
58 case Op386ANDLloadidx4:
59 return rewriteValue386_Op386ANDLloadidx4_0(v)
60 case Op386ANDLmodify:
61 return rewriteValue386_Op386ANDLmodify_0(v)
62 case Op386ANDLmodifyidx4:
63 return rewriteValue386_Op386ANDLmodifyidx4_0(v)
64 case Op386CMPB:
65 return rewriteValue386_Op386CMPB_0(v)
66 case Op386CMPBconst:
67 return rewriteValue386_Op386CMPBconst_0(v)
68 case Op386CMPBload:
69 return rewriteValue386_Op386CMPBload_0(v)
70 case Op386CMPL:
71 return rewriteValue386_Op386CMPL_0(v)
72 case Op386CMPLconst:
73 return rewriteValue386_Op386CMPLconst_0(v) || rewriteValue386_Op386CMPLconst_10(v)
74 case Op386CMPLload:
75 return rewriteValue386_Op386CMPLload_0(v)
76 case Op386CMPW:
77 return rewriteValue386_Op386CMPW_0(v)
78 case Op386CMPWconst:
79 return rewriteValue386_Op386CMPWconst_0(v)
80 case Op386CMPWload:
81 return rewriteValue386_Op386CMPWload_0(v)
82 case Op386DIVSD:
83 return rewriteValue386_Op386DIVSD_0(v)
84 case Op386DIVSDload:
85 return rewriteValue386_Op386DIVSDload_0(v)
86 case Op386DIVSS:
87 return rewriteValue386_Op386DIVSS_0(v)
88 case Op386DIVSSload:
89 return rewriteValue386_Op386DIVSSload_0(v)
90 case Op386LEAL:
91 return rewriteValue386_Op386LEAL_0(v)
92 case Op386LEAL1:
93 return rewriteValue386_Op386LEAL1_0(v)
94 case Op386LEAL2:
95 return rewriteValue386_Op386LEAL2_0(v)
96 case Op386LEAL4:
97 return rewriteValue386_Op386LEAL4_0(v)
98 case Op386LEAL8:
99 return rewriteValue386_Op386LEAL8_0(v)
100 case Op386MOVBLSX:
101 return rewriteValue386_Op386MOVBLSX_0(v)
102 case Op386MOVBLSXload:
103 return rewriteValue386_Op386MOVBLSXload_0(v)
104 case Op386MOVBLZX:
105 return rewriteValue386_Op386MOVBLZX_0(v)
106 case Op386MOVBload:
107 return rewriteValue386_Op386MOVBload_0(v)
108 case Op386MOVBloadidx1:
109 return rewriteValue386_Op386MOVBloadidx1_0(v)
110 case Op386MOVBstore:
111 return rewriteValue386_Op386MOVBstore_0(v) || rewriteValue386_Op386MOVBstore_10(v)
112 case Op386MOVBstoreconst:
113 return rewriteValue386_Op386MOVBstoreconst_0(v)
114 case Op386MOVBstoreconstidx1:
115 return rewriteValue386_Op386MOVBstoreconstidx1_0(v)
116 case Op386MOVBstoreidx1:
117 return rewriteValue386_Op386MOVBstoreidx1_0(v) || rewriteValue386_Op386MOVBstoreidx1_10(v) || rewriteValue386_Op386MOVBstoreidx1_20(v)
118 case Op386MOVLload:
119 return rewriteValue386_Op386MOVLload_0(v)
120 case Op386MOVLloadidx1:
121 return rewriteValue386_Op386MOVLloadidx1_0(v)
122 case Op386MOVLloadidx4:
123 return rewriteValue386_Op386MOVLloadidx4_0(v)
124 case Op386MOVLstore:
125 return rewriteValue386_Op386MOVLstore_0(v) || rewriteValue386_Op386MOVLstore_10(v) || rewriteValue386_Op386MOVLstore_20(v)
126 case Op386MOVLstoreconst:
127 return rewriteValue386_Op386MOVLstoreconst_0(v)
128 case Op386MOVLstoreconstidx1:
129 return rewriteValue386_Op386MOVLstoreconstidx1_0(v)
130 case Op386MOVLstoreconstidx4:
131 return rewriteValue386_Op386MOVLstoreconstidx4_0(v)
132 case Op386MOVLstoreidx1:
133 return rewriteValue386_Op386MOVLstoreidx1_0(v)
134 case Op386MOVLstoreidx4:
135 return rewriteValue386_Op386MOVLstoreidx4_0(v) || rewriteValue386_Op386MOVLstoreidx4_10(v)
136 case Op386MOVSDconst:
137 return rewriteValue386_Op386MOVSDconst_0(v)
138 case Op386MOVSDload:
139 return rewriteValue386_Op386MOVSDload_0(v)
140 case Op386MOVSDloadidx1:
141 return rewriteValue386_Op386MOVSDloadidx1_0(v)
142 case Op386MOVSDloadidx8:
143 return rewriteValue386_Op386MOVSDloadidx8_0(v)
144 case Op386MOVSDstore:
145 return rewriteValue386_Op386MOVSDstore_0(v)
146 case Op386MOVSDstoreidx1:
147 return rewriteValue386_Op386MOVSDstoreidx1_0(v)
148 case Op386MOVSDstoreidx8:
149 return rewriteValue386_Op386MOVSDstoreidx8_0(v)
150 case Op386MOVSSconst:
151 return rewriteValue386_Op386MOVSSconst_0(v)
152 case Op386MOVSSload:
153 return rewriteValue386_Op386MOVSSload_0(v)
154 case Op386MOVSSloadidx1:
155 return rewriteValue386_Op386MOVSSloadidx1_0(v)
156 case Op386MOVSSloadidx4:
157 return rewriteValue386_Op386MOVSSloadidx4_0(v)
158 case Op386MOVSSstore:
159 return rewriteValue386_Op386MOVSSstore_0(v)
160 case Op386MOVSSstoreidx1:
161 return rewriteValue386_Op386MOVSSstoreidx1_0(v)
162 case Op386MOVSSstoreidx4:
163 return rewriteValue386_Op386MOVSSstoreidx4_0(v)
164 case Op386MOVWLSX:
165 return rewriteValue386_Op386MOVWLSX_0(v)
166 case Op386MOVWLSXload:
167 return rewriteValue386_Op386MOVWLSXload_0(v)
168 case Op386MOVWLZX:
169 return rewriteValue386_Op386MOVWLZX_0(v)
170 case Op386MOVWload:
171 return rewriteValue386_Op386MOVWload_0(v)
172 case Op386MOVWloadidx1:
173 return rewriteValue386_Op386MOVWloadidx1_0(v)
174 case Op386MOVWloadidx2:
175 return rewriteValue386_Op386MOVWloadidx2_0(v)
176 case Op386MOVWstore:
177 return rewriteValue386_Op386MOVWstore_0(v)
178 case Op386MOVWstoreconst:
179 return rewriteValue386_Op386MOVWstoreconst_0(v)
180 case Op386MOVWstoreconstidx1:
181 return rewriteValue386_Op386MOVWstoreconstidx1_0(v)
182 case Op386MOVWstoreconstidx2:
183 return rewriteValue386_Op386MOVWstoreconstidx2_0(v)
184 case Op386MOVWstoreidx1:
185 return rewriteValue386_Op386MOVWstoreidx1_0(v) || rewriteValue386_Op386MOVWstoreidx1_10(v)
186 case Op386MOVWstoreidx2:
187 return rewriteValue386_Op386MOVWstoreidx2_0(v)
188 case Op386MULL:
189 return rewriteValue386_Op386MULL_0(v)
190 case Op386MULLconst:
191 return rewriteValue386_Op386MULLconst_0(v) || rewriteValue386_Op386MULLconst_10(v) || rewriteValue386_Op386MULLconst_20(v) || rewriteValue386_Op386MULLconst_30(v)
192 case Op386MULLload:
193 return rewriteValue386_Op386MULLload_0(v)
194 case Op386MULLloadidx4:
195 return rewriteValue386_Op386MULLloadidx4_0(v)
196 case Op386MULSD:
197 return rewriteValue386_Op386MULSD_0(v)
198 case Op386MULSDload:
199 return rewriteValue386_Op386MULSDload_0(v)
200 case Op386MULSS:
201 return rewriteValue386_Op386MULSS_0(v)
202 case Op386MULSSload:
203 return rewriteValue386_Op386MULSSload_0(v)
204 case Op386NEGL:
205 return rewriteValue386_Op386NEGL_0(v)
206 case Op386NOTL:
207 return rewriteValue386_Op386NOTL_0(v)
208 case Op386ORL:
209 return rewriteValue386_Op386ORL_0(v) || rewriteValue386_Op386ORL_10(v) || rewriteValue386_Op386ORL_20(v) || rewriteValue386_Op386ORL_30(v) || rewriteValue386_Op386ORL_40(v) || rewriteValue386_Op386ORL_50(v)
210 case Op386ORLconst:
211 return rewriteValue386_Op386ORLconst_0(v)
212 case Op386ORLconstmodify:
213 return rewriteValue386_Op386ORLconstmodify_0(v)
214 case Op386ORLconstmodifyidx4:
215 return rewriteValue386_Op386ORLconstmodifyidx4_0(v)
216 case Op386ORLload:
217 return rewriteValue386_Op386ORLload_0(v)
218 case Op386ORLloadidx4:
219 return rewriteValue386_Op386ORLloadidx4_0(v)
220 case Op386ORLmodify:
221 return rewriteValue386_Op386ORLmodify_0(v)
222 case Op386ORLmodifyidx4:
223 return rewriteValue386_Op386ORLmodifyidx4_0(v)
224 case Op386ROLBconst:
225 return rewriteValue386_Op386ROLBconst_0(v)
226 case Op386ROLLconst:
227 return rewriteValue386_Op386ROLLconst_0(v)
228 case Op386ROLWconst:
229 return rewriteValue386_Op386ROLWconst_0(v)
230 case Op386SARB:
231 return rewriteValue386_Op386SARB_0(v)
232 case Op386SARBconst:
233 return rewriteValue386_Op386SARBconst_0(v)
234 case Op386SARL:
235 return rewriteValue386_Op386SARL_0(v)
236 case Op386SARLconst:
237 return rewriteValue386_Op386SARLconst_0(v)
238 case Op386SARW:
239 return rewriteValue386_Op386SARW_0(v)
240 case Op386SARWconst:
241 return rewriteValue386_Op386SARWconst_0(v)
242 case Op386SBBL:
243 return rewriteValue386_Op386SBBL_0(v)
244 case Op386SBBLcarrymask:
245 return rewriteValue386_Op386SBBLcarrymask_0(v)
246 case Op386SETA:
247 return rewriteValue386_Op386SETA_0(v)
248 case Op386SETAE:
249 return rewriteValue386_Op386SETAE_0(v)
250 case Op386SETB:
251 return rewriteValue386_Op386SETB_0(v)
252 case Op386SETBE:
253 return rewriteValue386_Op386SETBE_0(v)
254 case Op386SETEQ:
255 return rewriteValue386_Op386SETEQ_0(v)
256 case Op386SETG:
257 return rewriteValue386_Op386SETG_0(v)
258 case Op386SETGE:
259 return rewriteValue386_Op386SETGE_0(v)
260 case Op386SETL:
261 return rewriteValue386_Op386SETL_0(v)
262 case Op386SETLE:
263 return rewriteValue386_Op386SETLE_0(v)
264 case Op386SETNE:
265 return rewriteValue386_Op386SETNE_0(v)
266 case Op386SHLL:
267 return rewriteValue386_Op386SHLL_0(v)
268 case Op386SHLLconst:
269 return rewriteValue386_Op386SHLLconst_0(v)
270 case Op386SHRB:
271 return rewriteValue386_Op386SHRB_0(v)
272 case Op386SHRBconst:
273 return rewriteValue386_Op386SHRBconst_0(v)
274 case Op386SHRL:
275 return rewriteValue386_Op386SHRL_0(v)
276 case Op386SHRLconst:
277 return rewriteValue386_Op386SHRLconst_0(v)
278 case Op386SHRW:
279 return rewriteValue386_Op386SHRW_0(v)
280 case Op386SHRWconst:
281 return rewriteValue386_Op386SHRWconst_0(v)
282 case Op386SUBL:
283 return rewriteValue386_Op386SUBL_0(v)
284 case Op386SUBLcarry:
285 return rewriteValue386_Op386SUBLcarry_0(v)
286 case Op386SUBLconst:
287 return rewriteValue386_Op386SUBLconst_0(v)
288 case Op386SUBLload:
289 return rewriteValue386_Op386SUBLload_0(v)
290 case Op386SUBLloadidx4:
291 return rewriteValue386_Op386SUBLloadidx4_0(v)
292 case Op386SUBLmodify:
293 return rewriteValue386_Op386SUBLmodify_0(v)
294 case Op386SUBLmodifyidx4:
295 return rewriteValue386_Op386SUBLmodifyidx4_0(v)
296 case Op386SUBSD:
297 return rewriteValue386_Op386SUBSD_0(v)
298 case Op386SUBSDload:
299 return rewriteValue386_Op386SUBSDload_0(v)
300 case Op386SUBSS:
301 return rewriteValue386_Op386SUBSS_0(v)
302 case Op386SUBSSload:
303 return rewriteValue386_Op386SUBSSload_0(v)
304 case Op386XORL:
305 return rewriteValue386_Op386XORL_0(v) || rewriteValue386_Op386XORL_10(v)
306 case Op386XORLconst:
307 return rewriteValue386_Op386XORLconst_0(v)
308 case Op386XORLconstmodify:
309 return rewriteValue386_Op386XORLconstmodify_0(v)
310 case Op386XORLconstmodifyidx4:
311 return rewriteValue386_Op386XORLconstmodifyidx4_0(v)
312 case Op386XORLload:
313 return rewriteValue386_Op386XORLload_0(v)
314 case Op386XORLloadidx4:
315 return rewriteValue386_Op386XORLloadidx4_0(v)
316 case Op386XORLmodify:
317 return rewriteValue386_Op386XORLmodify_0(v)
318 case Op386XORLmodifyidx4:
319 return rewriteValue386_Op386XORLmodifyidx4_0(v)
320 case OpAdd16:
321 return rewriteValue386_OpAdd16_0(v)
322 case OpAdd32:
323 return rewriteValue386_OpAdd32_0(v)
324 case OpAdd32F:
325 return rewriteValue386_OpAdd32F_0(v)
326 case OpAdd32carry:
327 return rewriteValue386_OpAdd32carry_0(v)
328 case OpAdd32withcarry:
329 return rewriteValue386_OpAdd32withcarry_0(v)
330 case OpAdd64F:
331 return rewriteValue386_OpAdd64F_0(v)
332 case OpAdd8:
333 return rewriteValue386_OpAdd8_0(v)
334 case OpAddPtr:
335 return rewriteValue386_OpAddPtr_0(v)
336 case OpAddr:
337 return rewriteValue386_OpAddr_0(v)
338 case OpAnd16:
339 return rewriteValue386_OpAnd16_0(v)
340 case OpAnd32:
341 return rewriteValue386_OpAnd32_0(v)
342 case OpAnd8:
343 return rewriteValue386_OpAnd8_0(v)
344 case OpAndB:
345 return rewriteValue386_OpAndB_0(v)
346 case OpAvg32u:
347 return rewriteValue386_OpAvg32u_0(v)
348 case OpBswap32:
349 return rewriteValue386_OpBswap32_0(v)
350 case OpClosureCall:
351 return rewriteValue386_OpClosureCall_0(v)
352 case OpCom16:
353 return rewriteValue386_OpCom16_0(v)
354 case OpCom32:
355 return rewriteValue386_OpCom32_0(v)
356 case OpCom8:
357 return rewriteValue386_OpCom8_0(v)
358 case OpConst16:
359 return rewriteValue386_OpConst16_0(v)
360 case OpConst32:
361 return rewriteValue386_OpConst32_0(v)
362 case OpConst32F:
363 return rewriteValue386_OpConst32F_0(v)
364 case OpConst64F:
365 return rewriteValue386_OpConst64F_0(v)
366 case OpConst8:
367 return rewriteValue386_OpConst8_0(v)
368 case OpConstBool:
369 return rewriteValue386_OpConstBool_0(v)
370 case OpConstNil:
371 return rewriteValue386_OpConstNil_0(v)
372 case OpCvt32Fto32:
373 return rewriteValue386_OpCvt32Fto32_0(v)
374 case OpCvt32Fto64F:
375 return rewriteValue386_OpCvt32Fto64F_0(v)
376 case OpCvt32to32F:
377 return rewriteValue386_OpCvt32to32F_0(v)
378 case OpCvt32to64F:
379 return rewriteValue386_OpCvt32to64F_0(v)
380 case OpCvt64Fto32:
381 return rewriteValue386_OpCvt64Fto32_0(v)
382 case OpCvt64Fto32F:
383 return rewriteValue386_OpCvt64Fto32F_0(v)
384 case OpDiv16:
385 return rewriteValue386_OpDiv16_0(v)
386 case OpDiv16u:
387 return rewriteValue386_OpDiv16u_0(v)
388 case OpDiv32:
389 return rewriteValue386_OpDiv32_0(v)
390 case OpDiv32F:
391 return rewriteValue386_OpDiv32F_0(v)
392 case OpDiv32u:
393 return rewriteValue386_OpDiv32u_0(v)
394 case OpDiv64F:
395 return rewriteValue386_OpDiv64F_0(v)
396 case OpDiv8:
397 return rewriteValue386_OpDiv8_0(v)
398 case OpDiv8u:
399 return rewriteValue386_OpDiv8u_0(v)
400 case OpEq16:
401 return rewriteValue386_OpEq16_0(v)
402 case OpEq32:
403 return rewriteValue386_OpEq32_0(v)
404 case OpEq32F:
405 return rewriteValue386_OpEq32F_0(v)
406 case OpEq64F:
407 return rewriteValue386_OpEq64F_0(v)
408 case OpEq8:
409 return rewriteValue386_OpEq8_0(v)
410 case OpEqB:
411 return rewriteValue386_OpEqB_0(v)
412 case OpEqPtr:
413 return rewriteValue386_OpEqPtr_0(v)
414 case OpGeq16:
415 return rewriteValue386_OpGeq16_0(v)
416 case OpGeq16U:
417 return rewriteValue386_OpGeq16U_0(v)
418 case OpGeq32:
419 return rewriteValue386_OpGeq32_0(v)
420 case OpGeq32F:
421 return rewriteValue386_OpGeq32F_0(v)
422 case OpGeq32U:
423 return rewriteValue386_OpGeq32U_0(v)
424 case OpGeq64F:
425 return rewriteValue386_OpGeq64F_0(v)
426 case OpGeq8:
427 return rewriteValue386_OpGeq8_0(v)
428 case OpGeq8U:
429 return rewriteValue386_OpGeq8U_0(v)
430 case OpGetCallerPC:
431 return rewriteValue386_OpGetCallerPC_0(v)
432 case OpGetCallerSP:
433 return rewriteValue386_OpGetCallerSP_0(v)
434 case OpGetClosurePtr:
435 return rewriteValue386_OpGetClosurePtr_0(v)
436 case OpGetG:
437 return rewriteValue386_OpGetG_0(v)
438 case OpGreater16:
439 return rewriteValue386_OpGreater16_0(v)
440 case OpGreater16U:
441 return rewriteValue386_OpGreater16U_0(v)
442 case OpGreater32:
443 return rewriteValue386_OpGreater32_0(v)
444 case OpGreater32F:
445 return rewriteValue386_OpGreater32F_0(v)
446 case OpGreater32U:
447 return rewriteValue386_OpGreater32U_0(v)
448 case OpGreater64F:
449 return rewriteValue386_OpGreater64F_0(v)
450 case OpGreater8:
451 return rewriteValue386_OpGreater8_0(v)
452 case OpGreater8U:
453 return rewriteValue386_OpGreater8U_0(v)
454 case OpHmul32:
455 return rewriteValue386_OpHmul32_0(v)
456 case OpHmul32u:
457 return rewriteValue386_OpHmul32u_0(v)
458 case OpInterCall:
459 return rewriteValue386_OpInterCall_0(v)
460 case OpIsInBounds:
461 return rewriteValue386_OpIsInBounds_0(v)
462 case OpIsNonNil:
463 return rewriteValue386_OpIsNonNil_0(v)
464 case OpIsSliceInBounds:
465 return rewriteValue386_OpIsSliceInBounds_0(v)
466 case OpLeq16:
467 return rewriteValue386_OpLeq16_0(v)
468 case OpLeq16U:
469 return rewriteValue386_OpLeq16U_0(v)
470 case OpLeq32:
471 return rewriteValue386_OpLeq32_0(v)
472 case OpLeq32F:
473 return rewriteValue386_OpLeq32F_0(v)
474 case OpLeq32U:
475 return rewriteValue386_OpLeq32U_0(v)
476 case OpLeq64F:
477 return rewriteValue386_OpLeq64F_0(v)
478 case OpLeq8:
479 return rewriteValue386_OpLeq8_0(v)
480 case OpLeq8U:
481 return rewriteValue386_OpLeq8U_0(v)
482 case OpLess16:
483 return rewriteValue386_OpLess16_0(v)
484 case OpLess16U:
485 return rewriteValue386_OpLess16U_0(v)
486 case OpLess32:
487 return rewriteValue386_OpLess32_0(v)
488 case OpLess32F:
489 return rewriteValue386_OpLess32F_0(v)
490 case OpLess32U:
491 return rewriteValue386_OpLess32U_0(v)
492 case OpLess64F:
493 return rewriteValue386_OpLess64F_0(v)
494 case OpLess8:
495 return rewriteValue386_OpLess8_0(v)
496 case OpLess8U:
497 return rewriteValue386_OpLess8U_0(v)
498 case OpLoad:
499 return rewriteValue386_OpLoad_0(v)
500 case OpLocalAddr:
501 return rewriteValue386_OpLocalAddr_0(v)
502 case OpLsh16x16:
503 return rewriteValue386_OpLsh16x16_0(v)
504 case OpLsh16x32:
505 return rewriteValue386_OpLsh16x32_0(v)
506 case OpLsh16x64:
507 return rewriteValue386_OpLsh16x64_0(v)
508 case OpLsh16x8:
509 return rewriteValue386_OpLsh16x8_0(v)
510 case OpLsh32x16:
511 return rewriteValue386_OpLsh32x16_0(v)
512 case OpLsh32x32:
513 return rewriteValue386_OpLsh32x32_0(v)
514 case OpLsh32x64:
515 return rewriteValue386_OpLsh32x64_0(v)
516 case OpLsh32x8:
517 return rewriteValue386_OpLsh32x8_0(v)
518 case OpLsh8x16:
519 return rewriteValue386_OpLsh8x16_0(v)
520 case OpLsh8x32:
521 return rewriteValue386_OpLsh8x32_0(v)
522 case OpLsh8x64:
523 return rewriteValue386_OpLsh8x64_0(v)
524 case OpLsh8x8:
525 return rewriteValue386_OpLsh8x8_0(v)
526 case OpMod16:
527 return rewriteValue386_OpMod16_0(v)
528 case OpMod16u:
529 return rewriteValue386_OpMod16u_0(v)
530 case OpMod32:
531 return rewriteValue386_OpMod32_0(v)
532 case OpMod32u:
533 return rewriteValue386_OpMod32u_0(v)
534 case OpMod8:
535 return rewriteValue386_OpMod8_0(v)
536 case OpMod8u:
537 return rewriteValue386_OpMod8u_0(v)
538 case OpMove:
539 return rewriteValue386_OpMove_0(v) || rewriteValue386_OpMove_10(v)
540 case OpMul16:
541 return rewriteValue386_OpMul16_0(v)
542 case OpMul32:
543 return rewriteValue386_OpMul32_0(v)
544 case OpMul32F:
545 return rewriteValue386_OpMul32F_0(v)
546 case OpMul32uhilo:
547 return rewriteValue386_OpMul32uhilo_0(v)
548 case OpMul64F:
549 return rewriteValue386_OpMul64F_0(v)
550 case OpMul8:
551 return rewriteValue386_OpMul8_0(v)
552 case OpNeg16:
553 return rewriteValue386_OpNeg16_0(v)
554 case OpNeg32:
555 return rewriteValue386_OpNeg32_0(v)
556 case OpNeg32F:
557 return rewriteValue386_OpNeg32F_0(v)
558 case OpNeg64F:
559 return rewriteValue386_OpNeg64F_0(v)
560 case OpNeg8:
561 return rewriteValue386_OpNeg8_0(v)
562 case OpNeq16:
563 return rewriteValue386_OpNeq16_0(v)
564 case OpNeq32:
565 return rewriteValue386_OpNeq32_0(v)
566 case OpNeq32F:
567 return rewriteValue386_OpNeq32F_0(v)
568 case OpNeq64F:
569 return rewriteValue386_OpNeq64F_0(v)
570 case OpNeq8:
571 return rewriteValue386_OpNeq8_0(v)
572 case OpNeqB:
573 return rewriteValue386_OpNeqB_0(v)
574 case OpNeqPtr:
575 return rewriteValue386_OpNeqPtr_0(v)
576 case OpNilCheck:
577 return rewriteValue386_OpNilCheck_0(v)
578 case OpNot:
579 return rewriteValue386_OpNot_0(v)
580 case OpOffPtr:
581 return rewriteValue386_OpOffPtr_0(v)
582 case OpOr16:
583 return rewriteValue386_OpOr16_0(v)
584 case OpOr32:
585 return rewriteValue386_OpOr32_0(v)
586 case OpOr8:
587 return rewriteValue386_OpOr8_0(v)
588 case OpOrB:
589 return rewriteValue386_OpOrB_0(v)
590 case OpPanicBounds:
591 return rewriteValue386_OpPanicBounds_0(v)
592 case OpPanicExtend:
593 return rewriteValue386_OpPanicExtend_0(v)
594 case OpRotateLeft16:
595 return rewriteValue386_OpRotateLeft16_0(v)
596 case OpRotateLeft32:
597 return rewriteValue386_OpRotateLeft32_0(v)
598 case OpRotateLeft8:
599 return rewriteValue386_OpRotateLeft8_0(v)
600 case OpRound32F:
601 return rewriteValue386_OpRound32F_0(v)
602 case OpRound64F:
603 return rewriteValue386_OpRound64F_0(v)
604 case OpRsh16Ux16:
605 return rewriteValue386_OpRsh16Ux16_0(v)
606 case OpRsh16Ux32:
607 return rewriteValue386_OpRsh16Ux32_0(v)
608 case OpRsh16Ux64:
609 return rewriteValue386_OpRsh16Ux64_0(v)
610 case OpRsh16Ux8:
611 return rewriteValue386_OpRsh16Ux8_0(v)
612 case OpRsh16x16:
613 return rewriteValue386_OpRsh16x16_0(v)
614 case OpRsh16x32:
615 return rewriteValue386_OpRsh16x32_0(v)
616 case OpRsh16x64:
617 return rewriteValue386_OpRsh16x64_0(v)
618 case OpRsh16x8:
619 return rewriteValue386_OpRsh16x8_0(v)
620 case OpRsh32Ux16:
621 return rewriteValue386_OpRsh32Ux16_0(v)
622 case OpRsh32Ux32:
623 return rewriteValue386_OpRsh32Ux32_0(v)
624 case OpRsh32Ux64:
625 return rewriteValue386_OpRsh32Ux64_0(v)
626 case OpRsh32Ux8:
627 return rewriteValue386_OpRsh32Ux8_0(v)
628 case OpRsh32x16:
629 return rewriteValue386_OpRsh32x16_0(v)
630 case OpRsh32x32:
631 return rewriteValue386_OpRsh32x32_0(v)
632 case OpRsh32x64:
633 return rewriteValue386_OpRsh32x64_0(v)
634 case OpRsh32x8:
635 return rewriteValue386_OpRsh32x8_0(v)
636 case OpRsh8Ux16:
637 return rewriteValue386_OpRsh8Ux16_0(v)
638 case OpRsh8Ux32:
639 return rewriteValue386_OpRsh8Ux32_0(v)
640 case OpRsh8Ux64:
641 return rewriteValue386_OpRsh8Ux64_0(v)
642 case OpRsh8Ux8:
643 return rewriteValue386_OpRsh8Ux8_0(v)
644 case OpRsh8x16:
645 return rewriteValue386_OpRsh8x16_0(v)
646 case OpRsh8x32:
647 return rewriteValue386_OpRsh8x32_0(v)
648 case OpRsh8x64:
649 return rewriteValue386_OpRsh8x64_0(v)
650 case OpRsh8x8:
651 return rewriteValue386_OpRsh8x8_0(v)
652 case OpSelect0:
653 return rewriteValue386_OpSelect0_0(v)
654 case OpSelect1:
655 return rewriteValue386_OpSelect1_0(v)
656 case OpSignExt16to32:
657 return rewriteValue386_OpSignExt16to32_0(v)
658 case OpSignExt8to16:
659 return rewriteValue386_OpSignExt8to16_0(v)
660 case OpSignExt8to32:
661 return rewriteValue386_OpSignExt8to32_0(v)
662 case OpSignmask:
663 return rewriteValue386_OpSignmask_0(v)
664 case OpSlicemask:
665 return rewriteValue386_OpSlicemask_0(v)
666 case OpSqrt:
667 return rewriteValue386_OpSqrt_0(v)
668 case OpStaticCall:
669 return rewriteValue386_OpStaticCall_0(v)
670 case OpStore:
671 return rewriteValue386_OpStore_0(v)
672 case OpSub16:
673 return rewriteValue386_OpSub16_0(v)
674 case OpSub32:
675 return rewriteValue386_OpSub32_0(v)
676 case OpSub32F:
677 return rewriteValue386_OpSub32F_0(v)
678 case OpSub32carry:
679 return rewriteValue386_OpSub32carry_0(v)
680 case OpSub32withcarry:
681 return rewriteValue386_OpSub32withcarry_0(v)
682 case OpSub64F:
683 return rewriteValue386_OpSub64F_0(v)
684 case OpSub8:
685 return rewriteValue386_OpSub8_0(v)
686 case OpSubPtr:
687 return rewriteValue386_OpSubPtr_0(v)
688 case OpTrunc16to8:
689 return rewriteValue386_OpTrunc16to8_0(v)
690 case OpTrunc32to16:
691 return rewriteValue386_OpTrunc32to16_0(v)
692 case OpTrunc32to8:
693 return rewriteValue386_OpTrunc32to8_0(v)
694 case OpWB:
695 return rewriteValue386_OpWB_0(v)
696 case OpXor16:
697 return rewriteValue386_OpXor16_0(v)
698 case OpXor32:
699 return rewriteValue386_OpXor32_0(v)
700 case OpXor8:
701 return rewriteValue386_OpXor8_0(v)
702 case OpZero:
703 return rewriteValue386_OpZero_0(v) || rewriteValue386_OpZero_10(v)
704 case OpZeroExt16to32:
705 return rewriteValue386_OpZeroExt16to32_0(v)
706 case OpZeroExt8to16:
707 return rewriteValue386_OpZeroExt8to16_0(v)
708 case OpZeroExt8to32:
709 return rewriteValue386_OpZeroExt8to32_0(v)
710 case OpZeromask:
711 return rewriteValue386_OpZeromask_0(v)
712 }
713 return false
714 }
715 func rewriteValue386_Op386ADCL_0(v *Value) bool {
716
717
718
719 for {
720 f := v.Args[2]
721 x := v.Args[0]
722 v_1 := v.Args[1]
723 if v_1.Op != Op386MOVLconst {
724 break
725 }
726 c := v_1.AuxInt
727 v.reset(Op386ADCLconst)
728 v.AuxInt = c
729 v.AddArg(x)
730 v.AddArg(f)
731 return true
732 }
733
734
735
736 for {
737 f := v.Args[2]
738 v_0 := v.Args[0]
739 if v_0.Op != Op386MOVLconst {
740 break
741 }
742 c := v_0.AuxInt
743 x := v.Args[1]
744 v.reset(Op386ADCLconst)
745 v.AuxInt = c
746 v.AddArg(x)
747 v.AddArg(f)
748 return true
749 }
750
751
752
753 for {
754 f := v.Args[2]
755 v_0 := v.Args[0]
756 if v_0.Op != Op386MOVLconst {
757 break
758 }
759 c := v_0.AuxInt
760 x := v.Args[1]
761 v.reset(Op386ADCLconst)
762 v.AuxInt = c
763 v.AddArg(x)
764 v.AddArg(f)
765 return true
766 }
767
768
769
770 for {
771 f := v.Args[2]
772 x := v.Args[0]
773 v_1 := v.Args[1]
774 if v_1.Op != Op386MOVLconst {
775 break
776 }
777 c := v_1.AuxInt
778 v.reset(Op386ADCLconst)
779 v.AuxInt = c
780 v.AddArg(x)
781 v.AddArg(f)
782 return true
783 }
784 return false
785 }
786 func rewriteValue386_Op386ADDL_0(v *Value) bool {
787
788
789
790 for {
791 _ = v.Args[1]
792 x := v.Args[0]
793 v_1 := v.Args[1]
794 if v_1.Op != Op386MOVLconst {
795 break
796 }
797 c := v_1.AuxInt
798 v.reset(Op386ADDLconst)
799 v.AuxInt = c
800 v.AddArg(x)
801 return true
802 }
803
804
805
806 for {
807 x := v.Args[1]
808 v_0 := v.Args[0]
809 if v_0.Op != Op386MOVLconst {
810 break
811 }
812 c := v_0.AuxInt
813 v.reset(Op386ADDLconst)
814 v.AuxInt = c
815 v.AddArg(x)
816 return true
817 }
818
819
820
821 for {
822 _ = v.Args[1]
823 v_0 := v.Args[0]
824 if v_0.Op != Op386SHLLconst {
825 break
826 }
827 c := v_0.AuxInt
828 x := v_0.Args[0]
829 v_1 := v.Args[1]
830 if v_1.Op != Op386SHRLconst {
831 break
832 }
833 d := v_1.AuxInt
834 if x != v_1.Args[0] {
835 break
836 }
837 if !(d == 32-c) {
838 break
839 }
840 v.reset(Op386ROLLconst)
841 v.AuxInt = c
842 v.AddArg(x)
843 return true
844 }
845
846
847
848 for {
849 _ = v.Args[1]
850 v_0 := v.Args[0]
851 if v_0.Op != Op386SHRLconst {
852 break
853 }
854 d := v_0.AuxInt
855 x := v_0.Args[0]
856 v_1 := v.Args[1]
857 if v_1.Op != Op386SHLLconst {
858 break
859 }
860 c := v_1.AuxInt
861 if x != v_1.Args[0] {
862 break
863 }
864 if !(d == 32-c) {
865 break
866 }
867 v.reset(Op386ROLLconst)
868 v.AuxInt = c
869 v.AddArg(x)
870 return true
871 }
872
873
874
875 for {
876 t := v.Type
877 _ = v.Args[1]
878 v_0 := v.Args[0]
879 if v_0.Op != Op386SHLLconst {
880 break
881 }
882 c := v_0.AuxInt
883 x := v_0.Args[0]
884 v_1 := v.Args[1]
885 if v_1.Op != Op386SHRWconst {
886 break
887 }
888 d := v_1.AuxInt
889 if x != v_1.Args[0] {
890 break
891 }
892 if !(c < 16 && d == 16-c && t.Size() == 2) {
893 break
894 }
895 v.reset(Op386ROLWconst)
896 v.AuxInt = c
897 v.AddArg(x)
898 return true
899 }
900
901
902
903 for {
904 t := v.Type
905 _ = v.Args[1]
906 v_0 := v.Args[0]
907 if v_0.Op != Op386SHRWconst {
908 break
909 }
910 d := v_0.AuxInt
911 x := v_0.Args[0]
912 v_1 := v.Args[1]
913 if v_1.Op != Op386SHLLconst {
914 break
915 }
916 c := v_1.AuxInt
917 if x != v_1.Args[0] {
918 break
919 }
920 if !(c < 16 && d == 16-c && t.Size() == 2) {
921 break
922 }
923 v.reset(Op386ROLWconst)
924 v.AuxInt = c
925 v.AddArg(x)
926 return true
927 }
928
929
930
931 for {
932 t := v.Type
933 _ = v.Args[1]
934 v_0 := v.Args[0]
935 if v_0.Op != Op386SHLLconst {
936 break
937 }
938 c := v_0.AuxInt
939 x := v_0.Args[0]
940 v_1 := v.Args[1]
941 if v_1.Op != Op386SHRBconst {
942 break
943 }
944 d := v_1.AuxInt
945 if x != v_1.Args[0] {
946 break
947 }
948 if !(c < 8 && d == 8-c && t.Size() == 1) {
949 break
950 }
951 v.reset(Op386ROLBconst)
952 v.AuxInt = c
953 v.AddArg(x)
954 return true
955 }
956
957
958
959 for {
960 t := v.Type
961 _ = v.Args[1]
962 v_0 := v.Args[0]
963 if v_0.Op != Op386SHRBconst {
964 break
965 }
966 d := v_0.AuxInt
967 x := v_0.Args[0]
968 v_1 := v.Args[1]
969 if v_1.Op != Op386SHLLconst {
970 break
971 }
972 c := v_1.AuxInt
973 if x != v_1.Args[0] {
974 break
975 }
976 if !(c < 8 && d == 8-c && t.Size() == 1) {
977 break
978 }
979 v.reset(Op386ROLBconst)
980 v.AuxInt = c
981 v.AddArg(x)
982 return true
983 }
984
985
986
987 for {
988 _ = v.Args[1]
989 x := v.Args[0]
990 v_1 := v.Args[1]
991 if v_1.Op != Op386SHLLconst {
992 break
993 }
994 if v_1.AuxInt != 3 {
995 break
996 }
997 y := v_1.Args[0]
998 v.reset(Op386LEAL8)
999 v.AddArg(x)
1000 v.AddArg(y)
1001 return true
1002 }
1003
1004
1005
1006 for {
1007 x := v.Args[1]
1008 v_0 := v.Args[0]
1009 if v_0.Op != Op386SHLLconst {
1010 break
1011 }
1012 if v_0.AuxInt != 3 {
1013 break
1014 }
1015 y := v_0.Args[0]
1016 v.reset(Op386LEAL8)
1017 v.AddArg(x)
1018 v.AddArg(y)
1019 return true
1020 }
1021 return false
1022 }
1023 func rewriteValue386_Op386ADDL_10(v *Value) bool {
1024
1025
1026
1027 for {
1028 _ = v.Args[1]
1029 x := v.Args[0]
1030 v_1 := v.Args[1]
1031 if v_1.Op != Op386SHLLconst {
1032 break
1033 }
1034 if v_1.AuxInt != 2 {
1035 break
1036 }
1037 y := v_1.Args[0]
1038 v.reset(Op386LEAL4)
1039 v.AddArg(x)
1040 v.AddArg(y)
1041 return true
1042 }
1043
1044
1045
1046 for {
1047 x := v.Args[1]
1048 v_0 := v.Args[0]
1049 if v_0.Op != Op386SHLLconst {
1050 break
1051 }
1052 if v_0.AuxInt != 2 {
1053 break
1054 }
1055 y := v_0.Args[0]
1056 v.reset(Op386LEAL4)
1057 v.AddArg(x)
1058 v.AddArg(y)
1059 return true
1060 }
1061
1062
1063
1064 for {
1065 _ = v.Args[1]
1066 x := v.Args[0]
1067 v_1 := v.Args[1]
1068 if v_1.Op != Op386SHLLconst {
1069 break
1070 }
1071 if v_1.AuxInt != 1 {
1072 break
1073 }
1074 y := v_1.Args[0]
1075 v.reset(Op386LEAL2)
1076 v.AddArg(x)
1077 v.AddArg(y)
1078 return true
1079 }
1080
1081
1082
1083 for {
1084 x := v.Args[1]
1085 v_0 := v.Args[0]
1086 if v_0.Op != Op386SHLLconst {
1087 break
1088 }
1089 if v_0.AuxInt != 1 {
1090 break
1091 }
1092 y := v_0.Args[0]
1093 v.reset(Op386LEAL2)
1094 v.AddArg(x)
1095 v.AddArg(y)
1096 return true
1097 }
1098
1099
1100
1101 for {
1102 _ = v.Args[1]
1103 x := v.Args[0]
1104 v_1 := v.Args[1]
1105 if v_1.Op != Op386ADDL {
1106 break
1107 }
1108 y := v_1.Args[1]
1109 if y != v_1.Args[0] {
1110 break
1111 }
1112 v.reset(Op386LEAL2)
1113 v.AddArg(x)
1114 v.AddArg(y)
1115 return true
1116 }
1117
1118
1119
1120 for {
1121 x := v.Args[1]
1122 v_0 := v.Args[0]
1123 if v_0.Op != Op386ADDL {
1124 break
1125 }
1126 y := v_0.Args[1]
1127 if y != v_0.Args[0] {
1128 break
1129 }
1130 v.reset(Op386LEAL2)
1131 v.AddArg(x)
1132 v.AddArg(y)
1133 return true
1134 }
1135
1136
1137
1138 for {
1139 _ = v.Args[1]
1140 x := v.Args[0]
1141 v_1 := v.Args[1]
1142 if v_1.Op != Op386ADDL {
1143 break
1144 }
1145 y := v_1.Args[1]
1146 if x != v_1.Args[0] {
1147 break
1148 }
1149 v.reset(Op386LEAL2)
1150 v.AddArg(y)
1151 v.AddArg(x)
1152 return true
1153 }
1154
1155
1156
1157 for {
1158 _ = v.Args[1]
1159 x := v.Args[0]
1160 v_1 := v.Args[1]
1161 if v_1.Op != Op386ADDL {
1162 break
1163 }
1164 _ = v_1.Args[1]
1165 y := v_1.Args[0]
1166 if x != v_1.Args[1] {
1167 break
1168 }
1169 v.reset(Op386LEAL2)
1170 v.AddArg(y)
1171 v.AddArg(x)
1172 return true
1173 }
1174
1175
1176
1177 for {
1178 x := v.Args[1]
1179 v_0 := v.Args[0]
1180 if v_0.Op != Op386ADDL {
1181 break
1182 }
1183 y := v_0.Args[1]
1184 if x != v_0.Args[0] {
1185 break
1186 }
1187 v.reset(Op386LEAL2)
1188 v.AddArg(y)
1189 v.AddArg(x)
1190 return true
1191 }
1192
1193
1194
1195 for {
1196 x := v.Args[1]
1197 v_0 := v.Args[0]
1198 if v_0.Op != Op386ADDL {
1199 break
1200 }
1201 _ = v_0.Args[1]
1202 y := v_0.Args[0]
1203 if x != v_0.Args[1] {
1204 break
1205 }
1206 v.reset(Op386LEAL2)
1207 v.AddArg(y)
1208 v.AddArg(x)
1209 return true
1210 }
1211 return false
1212 }
1213 func rewriteValue386_Op386ADDL_20(v *Value) bool {
1214
1215
1216
1217 for {
1218 y := v.Args[1]
1219 v_0 := v.Args[0]
1220 if v_0.Op != Op386ADDLconst {
1221 break
1222 }
1223 c := v_0.AuxInt
1224 x := v_0.Args[0]
1225 v.reset(Op386LEAL1)
1226 v.AuxInt = c
1227 v.AddArg(x)
1228 v.AddArg(y)
1229 return true
1230 }
1231
1232
1233
1234 for {
1235 _ = v.Args[1]
1236 y := v.Args[0]
1237 v_1 := v.Args[1]
1238 if v_1.Op != Op386ADDLconst {
1239 break
1240 }
1241 c := v_1.AuxInt
1242 x := v_1.Args[0]
1243 v.reset(Op386LEAL1)
1244 v.AuxInt = c
1245 v.AddArg(x)
1246 v.AddArg(y)
1247 return true
1248 }
1249
1250
1251
1252 for {
1253 _ = v.Args[1]
1254 x := v.Args[0]
1255 v_1 := v.Args[1]
1256 if v_1.Op != Op386LEAL {
1257 break
1258 }
1259 c := v_1.AuxInt
1260 s := v_1.Aux
1261 y := v_1.Args[0]
1262 if !(x.Op != OpSB && y.Op != OpSB) {
1263 break
1264 }
1265 v.reset(Op386LEAL1)
1266 v.AuxInt = c
1267 v.Aux = s
1268 v.AddArg(x)
1269 v.AddArg(y)
1270 return true
1271 }
1272
1273
1274
1275 for {
1276 x := v.Args[1]
1277 v_0 := v.Args[0]
1278 if v_0.Op != Op386LEAL {
1279 break
1280 }
1281 c := v_0.AuxInt
1282 s := v_0.Aux
1283 y := v_0.Args[0]
1284 if !(x.Op != OpSB && y.Op != OpSB) {
1285 break
1286 }
1287 v.reset(Op386LEAL1)
1288 v.AuxInt = c
1289 v.Aux = s
1290 v.AddArg(x)
1291 v.AddArg(y)
1292 return true
1293 }
1294
1295
1296
1297 for {
1298 _ = v.Args[1]
1299 x := v.Args[0]
1300 l := v.Args[1]
1301 if l.Op != Op386MOVLload {
1302 break
1303 }
1304 off := l.AuxInt
1305 sym := l.Aux
1306 mem := l.Args[1]
1307 ptr := l.Args[0]
1308 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
1309 break
1310 }
1311 v.reset(Op386ADDLload)
1312 v.AuxInt = off
1313 v.Aux = sym
1314 v.AddArg(x)
1315 v.AddArg(ptr)
1316 v.AddArg(mem)
1317 return true
1318 }
1319
1320
1321
1322 for {
1323 x := v.Args[1]
1324 l := v.Args[0]
1325 if l.Op != Op386MOVLload {
1326 break
1327 }
1328 off := l.AuxInt
1329 sym := l.Aux
1330 mem := l.Args[1]
1331 ptr := l.Args[0]
1332 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
1333 break
1334 }
1335 v.reset(Op386ADDLload)
1336 v.AuxInt = off
1337 v.Aux = sym
1338 v.AddArg(x)
1339 v.AddArg(ptr)
1340 v.AddArg(mem)
1341 return true
1342 }
1343
1344
1345
1346 for {
1347 _ = v.Args[1]
1348 x := v.Args[0]
1349 l := v.Args[1]
1350 if l.Op != Op386MOVLloadidx4 {
1351 break
1352 }
1353 off := l.AuxInt
1354 sym := l.Aux
1355 mem := l.Args[2]
1356 ptr := l.Args[0]
1357 idx := l.Args[1]
1358 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
1359 break
1360 }
1361 v.reset(Op386ADDLloadidx4)
1362 v.AuxInt = off
1363 v.Aux = sym
1364 v.AddArg(x)
1365 v.AddArg(ptr)
1366 v.AddArg(idx)
1367 v.AddArg(mem)
1368 return true
1369 }
1370
1371
1372
1373 for {
1374 x := v.Args[1]
1375 l := v.Args[0]
1376 if l.Op != Op386MOVLloadidx4 {
1377 break
1378 }
1379 off := l.AuxInt
1380 sym := l.Aux
1381 mem := l.Args[2]
1382 ptr := l.Args[0]
1383 idx := l.Args[1]
1384 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
1385 break
1386 }
1387 v.reset(Op386ADDLloadidx4)
1388 v.AuxInt = off
1389 v.Aux = sym
1390 v.AddArg(x)
1391 v.AddArg(ptr)
1392 v.AddArg(idx)
1393 v.AddArg(mem)
1394 return true
1395 }
1396
1397
1398
1399 for {
1400 _ = v.Args[1]
1401 x := v.Args[0]
1402 v_1 := v.Args[1]
1403 if v_1.Op != Op386NEGL {
1404 break
1405 }
1406 y := v_1.Args[0]
1407 v.reset(Op386SUBL)
1408 v.AddArg(x)
1409 v.AddArg(y)
1410 return true
1411 }
1412
1413
1414
1415 for {
1416 x := v.Args[1]
1417 v_0 := v.Args[0]
1418 if v_0.Op != Op386NEGL {
1419 break
1420 }
1421 y := v_0.Args[0]
1422 v.reset(Op386SUBL)
1423 v.AddArg(x)
1424 v.AddArg(y)
1425 return true
1426 }
1427 return false
1428 }
1429 func rewriteValue386_Op386ADDLcarry_0(v *Value) bool {
1430
1431
1432
1433 for {
1434 _ = v.Args[1]
1435 x := v.Args[0]
1436 v_1 := v.Args[1]
1437 if v_1.Op != Op386MOVLconst {
1438 break
1439 }
1440 c := v_1.AuxInt
1441 v.reset(Op386ADDLconstcarry)
1442 v.AuxInt = c
1443 v.AddArg(x)
1444 return true
1445 }
1446
1447
1448
1449 for {
1450 x := v.Args[1]
1451 v_0 := v.Args[0]
1452 if v_0.Op != Op386MOVLconst {
1453 break
1454 }
1455 c := v_0.AuxInt
1456 v.reset(Op386ADDLconstcarry)
1457 v.AuxInt = c
1458 v.AddArg(x)
1459 return true
1460 }
1461 return false
1462 }
1463 func rewriteValue386_Op386ADDLconst_0(v *Value) bool {
1464
1465
1466
1467 for {
1468 c := v.AuxInt
1469 v_0 := v.Args[0]
1470 if v_0.Op != Op386ADDL {
1471 break
1472 }
1473 y := v_0.Args[1]
1474 x := v_0.Args[0]
1475 v.reset(Op386LEAL1)
1476 v.AuxInt = c
1477 v.AddArg(x)
1478 v.AddArg(y)
1479 return true
1480 }
1481
1482
1483
1484 for {
1485 c := v.AuxInt
1486 v_0 := v.Args[0]
1487 if v_0.Op != Op386LEAL {
1488 break
1489 }
1490 d := v_0.AuxInt
1491 s := v_0.Aux
1492 x := v_0.Args[0]
1493 if !(is32Bit(c + d)) {
1494 break
1495 }
1496 v.reset(Op386LEAL)
1497 v.AuxInt = c + d
1498 v.Aux = s
1499 v.AddArg(x)
1500 return true
1501 }
1502
1503
1504
1505 for {
1506 c := v.AuxInt
1507 v_0 := v.Args[0]
1508 if v_0.Op != Op386LEAL1 {
1509 break
1510 }
1511 d := v_0.AuxInt
1512 s := v_0.Aux
1513 y := v_0.Args[1]
1514 x := v_0.Args[0]
1515 if !(is32Bit(c + d)) {
1516 break
1517 }
1518 v.reset(Op386LEAL1)
1519 v.AuxInt = c + d
1520 v.Aux = s
1521 v.AddArg(x)
1522 v.AddArg(y)
1523 return true
1524 }
1525
1526
1527
1528 for {
1529 c := v.AuxInt
1530 v_0 := v.Args[0]
1531 if v_0.Op != Op386LEAL2 {
1532 break
1533 }
1534 d := v_0.AuxInt
1535 s := v_0.Aux
1536 y := v_0.Args[1]
1537 x := v_0.Args[0]
1538 if !(is32Bit(c + d)) {
1539 break
1540 }
1541 v.reset(Op386LEAL2)
1542 v.AuxInt = c + d
1543 v.Aux = s
1544 v.AddArg(x)
1545 v.AddArg(y)
1546 return true
1547 }
1548
1549
1550
1551 for {
1552 c := v.AuxInt
1553 v_0 := v.Args[0]
1554 if v_0.Op != Op386LEAL4 {
1555 break
1556 }
1557 d := v_0.AuxInt
1558 s := v_0.Aux
1559 y := v_0.Args[1]
1560 x := v_0.Args[0]
1561 if !(is32Bit(c + d)) {
1562 break
1563 }
1564 v.reset(Op386LEAL4)
1565 v.AuxInt = c + d
1566 v.Aux = s
1567 v.AddArg(x)
1568 v.AddArg(y)
1569 return true
1570 }
1571
1572
1573
1574 for {
1575 c := v.AuxInt
1576 v_0 := v.Args[0]
1577 if v_0.Op != Op386LEAL8 {
1578 break
1579 }
1580 d := v_0.AuxInt
1581 s := v_0.Aux
1582 y := v_0.Args[1]
1583 x := v_0.Args[0]
1584 if !(is32Bit(c + d)) {
1585 break
1586 }
1587 v.reset(Op386LEAL8)
1588 v.AuxInt = c + d
1589 v.Aux = s
1590 v.AddArg(x)
1591 v.AddArg(y)
1592 return true
1593 }
1594
1595
1596
1597 for {
1598 c := v.AuxInt
1599 x := v.Args[0]
1600 if !(int32(c) == 0) {
1601 break
1602 }
1603 v.reset(OpCopy)
1604 v.Type = x.Type
1605 v.AddArg(x)
1606 return true
1607 }
1608
1609
1610
1611 for {
1612 c := v.AuxInt
1613 v_0 := v.Args[0]
1614 if v_0.Op != Op386MOVLconst {
1615 break
1616 }
1617 d := v_0.AuxInt
1618 v.reset(Op386MOVLconst)
1619 v.AuxInt = int64(int32(c + d))
1620 return true
1621 }
1622
1623
1624
1625 for {
1626 c := v.AuxInt
1627 v_0 := v.Args[0]
1628 if v_0.Op != Op386ADDLconst {
1629 break
1630 }
1631 d := v_0.AuxInt
1632 x := v_0.Args[0]
1633 v.reset(Op386ADDLconst)
1634 v.AuxInt = int64(int32(c + d))
1635 v.AddArg(x)
1636 return true
1637 }
1638 return false
1639 }
1640 func rewriteValue386_Op386ADDLconstmodify_0(v *Value) bool {
1641 b := v.Block
1642 config := b.Func.Config
1643
1644
1645
1646 for {
1647 valoff1 := v.AuxInt
1648 sym := v.Aux
1649 mem := v.Args[1]
1650 v_0 := v.Args[0]
1651 if v_0.Op != Op386ADDLconst {
1652 break
1653 }
1654 off2 := v_0.AuxInt
1655 base := v_0.Args[0]
1656 if !(ValAndOff(valoff1).canAdd(off2)) {
1657 break
1658 }
1659 v.reset(Op386ADDLconstmodify)
1660 v.AuxInt = ValAndOff(valoff1).add(off2)
1661 v.Aux = sym
1662 v.AddArg(base)
1663 v.AddArg(mem)
1664 return true
1665 }
1666
1667
1668
1669 for {
1670 valoff1 := v.AuxInt
1671 sym1 := v.Aux
1672 mem := v.Args[1]
1673 v_0 := v.Args[0]
1674 if v_0.Op != Op386LEAL {
1675 break
1676 }
1677 off2 := v_0.AuxInt
1678 sym2 := v_0.Aux
1679 base := v_0.Args[0]
1680 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
1681 break
1682 }
1683 v.reset(Op386ADDLconstmodify)
1684 v.AuxInt = ValAndOff(valoff1).add(off2)
1685 v.Aux = mergeSym(sym1, sym2)
1686 v.AddArg(base)
1687 v.AddArg(mem)
1688 return true
1689 }
1690 return false
1691 }
1692 func rewriteValue386_Op386ADDLconstmodifyidx4_0(v *Value) bool {
1693 b := v.Block
1694 config := b.Func.Config
1695
1696
1697
1698 for {
1699 valoff1 := v.AuxInt
1700 sym := v.Aux
1701 mem := v.Args[2]
1702 v_0 := v.Args[0]
1703 if v_0.Op != Op386ADDLconst {
1704 break
1705 }
1706 off2 := v_0.AuxInt
1707 base := v_0.Args[0]
1708 idx := v.Args[1]
1709 if !(ValAndOff(valoff1).canAdd(off2)) {
1710 break
1711 }
1712 v.reset(Op386ADDLconstmodifyidx4)
1713 v.AuxInt = ValAndOff(valoff1).add(off2)
1714 v.Aux = sym
1715 v.AddArg(base)
1716 v.AddArg(idx)
1717 v.AddArg(mem)
1718 return true
1719 }
1720
1721
1722
1723 for {
1724 valoff1 := v.AuxInt
1725 sym := v.Aux
1726 mem := v.Args[2]
1727 base := v.Args[0]
1728 v_1 := v.Args[1]
1729 if v_1.Op != Op386ADDLconst {
1730 break
1731 }
1732 off2 := v_1.AuxInt
1733 idx := v_1.Args[0]
1734 if !(ValAndOff(valoff1).canAdd(off2 * 4)) {
1735 break
1736 }
1737 v.reset(Op386ADDLconstmodifyidx4)
1738 v.AuxInt = ValAndOff(valoff1).add(off2 * 4)
1739 v.Aux = sym
1740 v.AddArg(base)
1741 v.AddArg(idx)
1742 v.AddArg(mem)
1743 return true
1744 }
1745
1746
1747
1748 for {
1749 valoff1 := v.AuxInt
1750 sym1 := v.Aux
1751 mem := v.Args[2]
1752 v_0 := v.Args[0]
1753 if v_0.Op != Op386LEAL {
1754 break
1755 }
1756 off2 := v_0.AuxInt
1757 sym2 := v_0.Aux
1758 base := v_0.Args[0]
1759 idx := v.Args[1]
1760 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
1761 break
1762 }
1763 v.reset(Op386ADDLconstmodifyidx4)
1764 v.AuxInt = ValAndOff(valoff1).add(off2)
1765 v.Aux = mergeSym(sym1, sym2)
1766 v.AddArg(base)
1767 v.AddArg(idx)
1768 v.AddArg(mem)
1769 return true
1770 }
1771 return false
1772 }
1773 func rewriteValue386_Op386ADDLload_0(v *Value) bool {
1774 b := v.Block
1775 config := b.Func.Config
1776
1777
1778
1779 for {
1780 off1 := v.AuxInt
1781 sym := v.Aux
1782 mem := v.Args[2]
1783 val := v.Args[0]
1784 v_1 := v.Args[1]
1785 if v_1.Op != Op386ADDLconst {
1786 break
1787 }
1788 off2 := v_1.AuxInt
1789 base := v_1.Args[0]
1790 if !(is32Bit(off1 + off2)) {
1791 break
1792 }
1793 v.reset(Op386ADDLload)
1794 v.AuxInt = off1 + off2
1795 v.Aux = sym
1796 v.AddArg(val)
1797 v.AddArg(base)
1798 v.AddArg(mem)
1799 return true
1800 }
1801
1802
1803
1804 for {
1805 off1 := v.AuxInt
1806 sym1 := v.Aux
1807 mem := v.Args[2]
1808 val := v.Args[0]
1809 v_1 := v.Args[1]
1810 if v_1.Op != Op386LEAL {
1811 break
1812 }
1813 off2 := v_1.AuxInt
1814 sym2 := v_1.Aux
1815 base := v_1.Args[0]
1816 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
1817 break
1818 }
1819 v.reset(Op386ADDLload)
1820 v.AuxInt = off1 + off2
1821 v.Aux = mergeSym(sym1, sym2)
1822 v.AddArg(val)
1823 v.AddArg(base)
1824 v.AddArg(mem)
1825 return true
1826 }
1827
1828
1829
1830 for {
1831 off1 := v.AuxInt
1832 sym1 := v.Aux
1833 mem := v.Args[2]
1834 val := v.Args[0]
1835 v_1 := v.Args[1]
1836 if v_1.Op != Op386LEAL4 {
1837 break
1838 }
1839 off2 := v_1.AuxInt
1840 sym2 := v_1.Aux
1841 idx := v_1.Args[1]
1842 ptr := v_1.Args[0]
1843 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
1844 break
1845 }
1846 v.reset(Op386ADDLloadidx4)
1847 v.AuxInt = off1 + off2
1848 v.Aux = mergeSym(sym1, sym2)
1849 v.AddArg(val)
1850 v.AddArg(ptr)
1851 v.AddArg(idx)
1852 v.AddArg(mem)
1853 return true
1854 }
1855 return false
1856 }
1857 func rewriteValue386_Op386ADDLloadidx4_0(v *Value) bool {
1858 b := v.Block
1859 config := b.Func.Config
1860
1861
1862
1863 for {
1864 off1 := v.AuxInt
1865 sym := v.Aux
1866 mem := v.Args[3]
1867 val := v.Args[0]
1868 v_1 := v.Args[1]
1869 if v_1.Op != Op386ADDLconst {
1870 break
1871 }
1872 off2 := v_1.AuxInt
1873 base := v_1.Args[0]
1874 idx := v.Args[2]
1875 if !(is32Bit(off1 + off2)) {
1876 break
1877 }
1878 v.reset(Op386ADDLloadidx4)
1879 v.AuxInt = off1 + off2
1880 v.Aux = sym
1881 v.AddArg(val)
1882 v.AddArg(base)
1883 v.AddArg(idx)
1884 v.AddArg(mem)
1885 return true
1886 }
1887
1888
1889
1890 for {
1891 off1 := v.AuxInt
1892 sym := v.Aux
1893 mem := v.Args[3]
1894 val := v.Args[0]
1895 base := v.Args[1]
1896 v_2 := v.Args[2]
1897 if v_2.Op != Op386ADDLconst {
1898 break
1899 }
1900 off2 := v_2.AuxInt
1901 idx := v_2.Args[0]
1902 if !(is32Bit(off1 + off2*4)) {
1903 break
1904 }
1905 v.reset(Op386ADDLloadidx4)
1906 v.AuxInt = off1 + off2*4
1907 v.Aux = sym
1908 v.AddArg(val)
1909 v.AddArg(base)
1910 v.AddArg(idx)
1911 v.AddArg(mem)
1912 return true
1913 }
1914
1915
1916
1917 for {
1918 off1 := v.AuxInt
1919 sym1 := v.Aux
1920 mem := v.Args[3]
1921 val := v.Args[0]
1922 v_1 := v.Args[1]
1923 if v_1.Op != Op386LEAL {
1924 break
1925 }
1926 off2 := v_1.AuxInt
1927 sym2 := v_1.Aux
1928 base := v_1.Args[0]
1929 idx := v.Args[2]
1930 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
1931 break
1932 }
1933 v.reset(Op386ADDLloadidx4)
1934 v.AuxInt = off1 + off2
1935 v.Aux = mergeSym(sym1, sym2)
1936 v.AddArg(val)
1937 v.AddArg(base)
1938 v.AddArg(idx)
1939 v.AddArg(mem)
1940 return true
1941 }
1942 return false
1943 }
1944 func rewriteValue386_Op386ADDLmodify_0(v *Value) bool {
1945 b := v.Block
1946 config := b.Func.Config
1947
1948
1949
1950 for {
1951 off1 := v.AuxInt
1952 sym := v.Aux
1953 mem := v.Args[2]
1954 v_0 := v.Args[0]
1955 if v_0.Op != Op386ADDLconst {
1956 break
1957 }
1958 off2 := v_0.AuxInt
1959 base := v_0.Args[0]
1960 val := v.Args[1]
1961 if !(is32Bit(off1 + off2)) {
1962 break
1963 }
1964 v.reset(Op386ADDLmodify)
1965 v.AuxInt = off1 + off2
1966 v.Aux = sym
1967 v.AddArg(base)
1968 v.AddArg(val)
1969 v.AddArg(mem)
1970 return true
1971 }
1972
1973
1974
1975 for {
1976 off1 := v.AuxInt
1977 sym1 := v.Aux
1978 mem := v.Args[2]
1979 v_0 := v.Args[0]
1980 if v_0.Op != Op386LEAL {
1981 break
1982 }
1983 off2 := v_0.AuxInt
1984 sym2 := v_0.Aux
1985 base := v_0.Args[0]
1986 val := v.Args[1]
1987 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
1988 break
1989 }
1990 v.reset(Op386ADDLmodify)
1991 v.AuxInt = off1 + off2
1992 v.Aux = mergeSym(sym1, sym2)
1993 v.AddArg(base)
1994 v.AddArg(val)
1995 v.AddArg(mem)
1996 return true
1997 }
1998 return false
1999 }
2000 func rewriteValue386_Op386ADDLmodifyidx4_0(v *Value) bool {
2001 b := v.Block
2002 config := b.Func.Config
2003
2004
2005
2006 for {
2007 off1 := v.AuxInt
2008 sym := v.Aux
2009 mem := v.Args[3]
2010 v_0 := v.Args[0]
2011 if v_0.Op != Op386ADDLconst {
2012 break
2013 }
2014 off2 := v_0.AuxInt
2015 base := v_0.Args[0]
2016 idx := v.Args[1]
2017 val := v.Args[2]
2018 if !(is32Bit(off1 + off2)) {
2019 break
2020 }
2021 v.reset(Op386ADDLmodifyidx4)
2022 v.AuxInt = off1 + off2
2023 v.Aux = sym
2024 v.AddArg(base)
2025 v.AddArg(idx)
2026 v.AddArg(val)
2027 v.AddArg(mem)
2028 return true
2029 }
2030
2031
2032
2033 for {
2034 off1 := v.AuxInt
2035 sym := v.Aux
2036 mem := v.Args[3]
2037 base := v.Args[0]
2038 v_1 := v.Args[1]
2039 if v_1.Op != Op386ADDLconst {
2040 break
2041 }
2042 off2 := v_1.AuxInt
2043 idx := v_1.Args[0]
2044 val := v.Args[2]
2045 if !(is32Bit(off1 + off2*4)) {
2046 break
2047 }
2048 v.reset(Op386ADDLmodifyidx4)
2049 v.AuxInt = off1 + off2*4
2050 v.Aux = sym
2051 v.AddArg(base)
2052 v.AddArg(idx)
2053 v.AddArg(val)
2054 v.AddArg(mem)
2055 return true
2056 }
2057
2058
2059
2060 for {
2061 off1 := v.AuxInt
2062 sym1 := v.Aux
2063 mem := v.Args[3]
2064 v_0 := v.Args[0]
2065 if v_0.Op != Op386LEAL {
2066 break
2067 }
2068 off2 := v_0.AuxInt
2069 sym2 := v_0.Aux
2070 base := v_0.Args[0]
2071 idx := v.Args[1]
2072 val := v.Args[2]
2073 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
2074 break
2075 }
2076 v.reset(Op386ADDLmodifyidx4)
2077 v.AuxInt = off1 + off2
2078 v.Aux = mergeSym(sym1, sym2)
2079 v.AddArg(base)
2080 v.AddArg(idx)
2081 v.AddArg(val)
2082 v.AddArg(mem)
2083 return true
2084 }
2085
2086
2087
2088 for {
2089 off := v.AuxInt
2090 sym := v.Aux
2091 mem := v.Args[3]
2092 ptr := v.Args[0]
2093 idx := v.Args[1]
2094 v_2 := v.Args[2]
2095 if v_2.Op != Op386MOVLconst {
2096 break
2097 }
2098 c := v_2.AuxInt
2099 if !(validValAndOff(c, off)) {
2100 break
2101 }
2102 v.reset(Op386ADDLconstmodifyidx4)
2103 v.AuxInt = makeValAndOff(c, off)
2104 v.Aux = sym
2105 v.AddArg(ptr)
2106 v.AddArg(idx)
2107 v.AddArg(mem)
2108 return true
2109 }
2110 return false
2111 }
2112 func rewriteValue386_Op386ADDSD_0(v *Value) bool {
2113 b := v.Block
2114 config := b.Func.Config
2115
2116
2117
2118 for {
2119 _ = v.Args[1]
2120 x := v.Args[0]
2121 l := v.Args[1]
2122 if l.Op != Op386MOVSDload {
2123 break
2124 }
2125 off := l.AuxInt
2126 sym := l.Aux
2127 mem := l.Args[1]
2128 ptr := l.Args[0]
2129 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
2130 break
2131 }
2132 v.reset(Op386ADDSDload)
2133 v.AuxInt = off
2134 v.Aux = sym
2135 v.AddArg(x)
2136 v.AddArg(ptr)
2137 v.AddArg(mem)
2138 return true
2139 }
2140
2141
2142
2143 for {
2144 x := v.Args[1]
2145 l := v.Args[0]
2146 if l.Op != Op386MOVSDload {
2147 break
2148 }
2149 off := l.AuxInt
2150 sym := l.Aux
2151 mem := l.Args[1]
2152 ptr := l.Args[0]
2153 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
2154 break
2155 }
2156 v.reset(Op386ADDSDload)
2157 v.AuxInt = off
2158 v.Aux = sym
2159 v.AddArg(x)
2160 v.AddArg(ptr)
2161 v.AddArg(mem)
2162 return true
2163 }
2164 return false
2165 }
2166 func rewriteValue386_Op386ADDSDload_0(v *Value) bool {
2167 b := v.Block
2168 config := b.Func.Config
2169
2170
2171
2172 for {
2173 off1 := v.AuxInt
2174 sym := v.Aux
2175 mem := v.Args[2]
2176 val := v.Args[0]
2177 v_1 := v.Args[1]
2178 if v_1.Op != Op386ADDLconst {
2179 break
2180 }
2181 off2 := v_1.AuxInt
2182 base := v_1.Args[0]
2183 if !(is32Bit(off1 + off2)) {
2184 break
2185 }
2186 v.reset(Op386ADDSDload)
2187 v.AuxInt = off1 + off2
2188 v.Aux = sym
2189 v.AddArg(val)
2190 v.AddArg(base)
2191 v.AddArg(mem)
2192 return true
2193 }
2194
2195
2196
2197 for {
2198 off1 := v.AuxInt
2199 sym1 := v.Aux
2200 mem := v.Args[2]
2201 val := v.Args[0]
2202 v_1 := v.Args[1]
2203 if v_1.Op != Op386LEAL {
2204 break
2205 }
2206 off2 := v_1.AuxInt
2207 sym2 := v_1.Aux
2208 base := v_1.Args[0]
2209 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
2210 break
2211 }
2212 v.reset(Op386ADDSDload)
2213 v.AuxInt = off1 + off2
2214 v.Aux = mergeSym(sym1, sym2)
2215 v.AddArg(val)
2216 v.AddArg(base)
2217 v.AddArg(mem)
2218 return true
2219 }
2220 return false
2221 }
2222 func rewriteValue386_Op386ADDSS_0(v *Value) bool {
2223 b := v.Block
2224 config := b.Func.Config
2225
2226
2227
2228 for {
2229 _ = v.Args[1]
2230 x := v.Args[0]
2231 l := v.Args[1]
2232 if l.Op != Op386MOVSSload {
2233 break
2234 }
2235 off := l.AuxInt
2236 sym := l.Aux
2237 mem := l.Args[1]
2238 ptr := l.Args[0]
2239 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
2240 break
2241 }
2242 v.reset(Op386ADDSSload)
2243 v.AuxInt = off
2244 v.Aux = sym
2245 v.AddArg(x)
2246 v.AddArg(ptr)
2247 v.AddArg(mem)
2248 return true
2249 }
2250
2251
2252
2253 for {
2254 x := v.Args[1]
2255 l := v.Args[0]
2256 if l.Op != Op386MOVSSload {
2257 break
2258 }
2259 off := l.AuxInt
2260 sym := l.Aux
2261 mem := l.Args[1]
2262 ptr := l.Args[0]
2263 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
2264 break
2265 }
2266 v.reset(Op386ADDSSload)
2267 v.AuxInt = off
2268 v.Aux = sym
2269 v.AddArg(x)
2270 v.AddArg(ptr)
2271 v.AddArg(mem)
2272 return true
2273 }
2274 return false
2275 }
2276 func rewriteValue386_Op386ADDSSload_0(v *Value) bool {
2277 b := v.Block
2278 config := b.Func.Config
2279
2280
2281
2282 for {
2283 off1 := v.AuxInt
2284 sym := v.Aux
2285 mem := v.Args[2]
2286 val := v.Args[0]
2287 v_1 := v.Args[1]
2288 if v_1.Op != Op386ADDLconst {
2289 break
2290 }
2291 off2 := v_1.AuxInt
2292 base := v_1.Args[0]
2293 if !(is32Bit(off1 + off2)) {
2294 break
2295 }
2296 v.reset(Op386ADDSSload)
2297 v.AuxInt = off1 + off2
2298 v.Aux = sym
2299 v.AddArg(val)
2300 v.AddArg(base)
2301 v.AddArg(mem)
2302 return true
2303 }
2304
2305
2306
2307 for {
2308 off1 := v.AuxInt
2309 sym1 := v.Aux
2310 mem := v.Args[2]
2311 val := v.Args[0]
2312 v_1 := v.Args[1]
2313 if v_1.Op != Op386LEAL {
2314 break
2315 }
2316 off2 := v_1.AuxInt
2317 sym2 := v_1.Aux
2318 base := v_1.Args[0]
2319 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
2320 break
2321 }
2322 v.reset(Op386ADDSSload)
2323 v.AuxInt = off1 + off2
2324 v.Aux = mergeSym(sym1, sym2)
2325 v.AddArg(val)
2326 v.AddArg(base)
2327 v.AddArg(mem)
2328 return true
2329 }
2330 return false
2331 }
2332 func rewriteValue386_Op386ANDL_0(v *Value) bool {
2333
2334
2335
2336 for {
2337 _ = v.Args[1]
2338 x := v.Args[0]
2339 v_1 := v.Args[1]
2340 if v_1.Op != Op386MOVLconst {
2341 break
2342 }
2343 c := v_1.AuxInt
2344 v.reset(Op386ANDLconst)
2345 v.AuxInt = c
2346 v.AddArg(x)
2347 return true
2348 }
2349
2350
2351
2352 for {
2353 x := v.Args[1]
2354 v_0 := v.Args[0]
2355 if v_0.Op != Op386MOVLconst {
2356 break
2357 }
2358 c := v_0.AuxInt
2359 v.reset(Op386ANDLconst)
2360 v.AuxInt = c
2361 v.AddArg(x)
2362 return true
2363 }
2364
2365
2366
2367 for {
2368 _ = v.Args[1]
2369 x := v.Args[0]
2370 l := v.Args[1]
2371 if l.Op != Op386MOVLload {
2372 break
2373 }
2374 off := l.AuxInt
2375 sym := l.Aux
2376 mem := l.Args[1]
2377 ptr := l.Args[0]
2378 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
2379 break
2380 }
2381 v.reset(Op386ANDLload)
2382 v.AuxInt = off
2383 v.Aux = sym
2384 v.AddArg(x)
2385 v.AddArg(ptr)
2386 v.AddArg(mem)
2387 return true
2388 }
2389
2390
2391
2392 for {
2393 x := v.Args[1]
2394 l := v.Args[0]
2395 if l.Op != Op386MOVLload {
2396 break
2397 }
2398 off := l.AuxInt
2399 sym := l.Aux
2400 mem := l.Args[1]
2401 ptr := l.Args[0]
2402 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
2403 break
2404 }
2405 v.reset(Op386ANDLload)
2406 v.AuxInt = off
2407 v.Aux = sym
2408 v.AddArg(x)
2409 v.AddArg(ptr)
2410 v.AddArg(mem)
2411 return true
2412 }
2413
2414
2415
2416 for {
2417 _ = v.Args[1]
2418 x := v.Args[0]
2419 l := v.Args[1]
2420 if l.Op != Op386MOVLloadidx4 {
2421 break
2422 }
2423 off := l.AuxInt
2424 sym := l.Aux
2425 mem := l.Args[2]
2426 ptr := l.Args[0]
2427 idx := l.Args[1]
2428 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
2429 break
2430 }
2431 v.reset(Op386ANDLloadidx4)
2432 v.AuxInt = off
2433 v.Aux = sym
2434 v.AddArg(x)
2435 v.AddArg(ptr)
2436 v.AddArg(idx)
2437 v.AddArg(mem)
2438 return true
2439 }
2440
2441
2442
2443 for {
2444 x := v.Args[1]
2445 l := v.Args[0]
2446 if l.Op != Op386MOVLloadidx4 {
2447 break
2448 }
2449 off := l.AuxInt
2450 sym := l.Aux
2451 mem := l.Args[2]
2452 ptr := l.Args[0]
2453 idx := l.Args[1]
2454 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
2455 break
2456 }
2457 v.reset(Op386ANDLloadidx4)
2458 v.AuxInt = off
2459 v.Aux = sym
2460 v.AddArg(x)
2461 v.AddArg(ptr)
2462 v.AddArg(idx)
2463 v.AddArg(mem)
2464 return true
2465 }
2466
2467
2468
2469 for {
2470 x := v.Args[1]
2471 if x != v.Args[0] {
2472 break
2473 }
2474 v.reset(OpCopy)
2475 v.Type = x.Type
2476 v.AddArg(x)
2477 return true
2478 }
2479 return false
2480 }
2481 func rewriteValue386_Op386ANDLconst_0(v *Value) bool {
2482
2483
2484
2485 for {
2486 c := v.AuxInt
2487 v_0 := v.Args[0]
2488 if v_0.Op != Op386ANDLconst {
2489 break
2490 }
2491 d := v_0.AuxInt
2492 x := v_0.Args[0]
2493 v.reset(Op386ANDLconst)
2494 v.AuxInt = c & d
2495 v.AddArg(x)
2496 return true
2497 }
2498
2499
2500
2501 for {
2502 c := v.AuxInt
2503 if !(int32(c) == 0) {
2504 break
2505 }
2506 v.reset(Op386MOVLconst)
2507 v.AuxInt = 0
2508 return true
2509 }
2510
2511
2512
2513 for {
2514 c := v.AuxInt
2515 x := v.Args[0]
2516 if !(int32(c) == -1) {
2517 break
2518 }
2519 v.reset(OpCopy)
2520 v.Type = x.Type
2521 v.AddArg(x)
2522 return true
2523 }
2524
2525
2526
2527 for {
2528 c := v.AuxInt
2529 v_0 := v.Args[0]
2530 if v_0.Op != Op386MOVLconst {
2531 break
2532 }
2533 d := v_0.AuxInt
2534 v.reset(Op386MOVLconst)
2535 v.AuxInt = c & d
2536 return true
2537 }
2538 return false
2539 }
2540 func rewriteValue386_Op386ANDLconstmodify_0(v *Value) bool {
2541 b := v.Block
2542 config := b.Func.Config
2543
2544
2545
2546 for {
2547 valoff1 := v.AuxInt
2548 sym := v.Aux
2549 mem := v.Args[1]
2550 v_0 := v.Args[0]
2551 if v_0.Op != Op386ADDLconst {
2552 break
2553 }
2554 off2 := v_0.AuxInt
2555 base := v_0.Args[0]
2556 if !(ValAndOff(valoff1).canAdd(off2)) {
2557 break
2558 }
2559 v.reset(Op386ANDLconstmodify)
2560 v.AuxInt = ValAndOff(valoff1).add(off2)
2561 v.Aux = sym
2562 v.AddArg(base)
2563 v.AddArg(mem)
2564 return true
2565 }
2566
2567
2568
2569 for {
2570 valoff1 := v.AuxInt
2571 sym1 := v.Aux
2572 mem := v.Args[1]
2573 v_0 := v.Args[0]
2574 if v_0.Op != Op386LEAL {
2575 break
2576 }
2577 off2 := v_0.AuxInt
2578 sym2 := v_0.Aux
2579 base := v_0.Args[0]
2580 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
2581 break
2582 }
2583 v.reset(Op386ANDLconstmodify)
2584 v.AuxInt = ValAndOff(valoff1).add(off2)
2585 v.Aux = mergeSym(sym1, sym2)
2586 v.AddArg(base)
2587 v.AddArg(mem)
2588 return true
2589 }
2590 return false
2591 }
2592 func rewriteValue386_Op386ANDLconstmodifyidx4_0(v *Value) bool {
2593 b := v.Block
2594 config := b.Func.Config
2595
2596
2597
2598 for {
2599 valoff1 := v.AuxInt
2600 sym := v.Aux
2601 mem := v.Args[2]
2602 v_0 := v.Args[0]
2603 if v_0.Op != Op386ADDLconst {
2604 break
2605 }
2606 off2 := v_0.AuxInt
2607 base := v_0.Args[0]
2608 idx := v.Args[1]
2609 if !(ValAndOff(valoff1).canAdd(off2)) {
2610 break
2611 }
2612 v.reset(Op386ANDLconstmodifyidx4)
2613 v.AuxInt = ValAndOff(valoff1).add(off2)
2614 v.Aux = sym
2615 v.AddArg(base)
2616 v.AddArg(idx)
2617 v.AddArg(mem)
2618 return true
2619 }
2620
2621
2622
2623 for {
2624 valoff1 := v.AuxInt
2625 sym := v.Aux
2626 mem := v.Args[2]
2627 base := v.Args[0]
2628 v_1 := v.Args[1]
2629 if v_1.Op != Op386ADDLconst {
2630 break
2631 }
2632 off2 := v_1.AuxInt
2633 idx := v_1.Args[0]
2634 if !(ValAndOff(valoff1).canAdd(off2 * 4)) {
2635 break
2636 }
2637 v.reset(Op386ANDLconstmodifyidx4)
2638 v.AuxInt = ValAndOff(valoff1).add(off2 * 4)
2639 v.Aux = sym
2640 v.AddArg(base)
2641 v.AddArg(idx)
2642 v.AddArg(mem)
2643 return true
2644 }
2645
2646
2647
2648 for {
2649 valoff1 := v.AuxInt
2650 sym1 := v.Aux
2651 mem := v.Args[2]
2652 v_0 := v.Args[0]
2653 if v_0.Op != Op386LEAL {
2654 break
2655 }
2656 off2 := v_0.AuxInt
2657 sym2 := v_0.Aux
2658 base := v_0.Args[0]
2659 idx := v.Args[1]
2660 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
2661 break
2662 }
2663 v.reset(Op386ANDLconstmodifyidx4)
2664 v.AuxInt = ValAndOff(valoff1).add(off2)
2665 v.Aux = mergeSym(sym1, sym2)
2666 v.AddArg(base)
2667 v.AddArg(idx)
2668 v.AddArg(mem)
2669 return true
2670 }
2671 return false
2672 }
2673 func rewriteValue386_Op386ANDLload_0(v *Value) bool {
2674 b := v.Block
2675 config := b.Func.Config
2676
2677
2678
2679 for {
2680 off1 := v.AuxInt
2681 sym := v.Aux
2682 mem := v.Args[2]
2683 val := v.Args[0]
2684 v_1 := v.Args[1]
2685 if v_1.Op != Op386ADDLconst {
2686 break
2687 }
2688 off2 := v_1.AuxInt
2689 base := v_1.Args[0]
2690 if !(is32Bit(off1 + off2)) {
2691 break
2692 }
2693 v.reset(Op386ANDLload)
2694 v.AuxInt = off1 + off2
2695 v.Aux = sym
2696 v.AddArg(val)
2697 v.AddArg(base)
2698 v.AddArg(mem)
2699 return true
2700 }
2701
2702
2703
2704 for {
2705 off1 := v.AuxInt
2706 sym1 := v.Aux
2707 mem := v.Args[2]
2708 val := v.Args[0]
2709 v_1 := v.Args[1]
2710 if v_1.Op != Op386LEAL {
2711 break
2712 }
2713 off2 := v_1.AuxInt
2714 sym2 := v_1.Aux
2715 base := v_1.Args[0]
2716 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
2717 break
2718 }
2719 v.reset(Op386ANDLload)
2720 v.AuxInt = off1 + off2
2721 v.Aux = mergeSym(sym1, sym2)
2722 v.AddArg(val)
2723 v.AddArg(base)
2724 v.AddArg(mem)
2725 return true
2726 }
2727
2728
2729
2730 for {
2731 off1 := v.AuxInt
2732 sym1 := v.Aux
2733 mem := v.Args[2]
2734 val := v.Args[0]
2735 v_1 := v.Args[1]
2736 if v_1.Op != Op386LEAL4 {
2737 break
2738 }
2739 off2 := v_1.AuxInt
2740 sym2 := v_1.Aux
2741 idx := v_1.Args[1]
2742 ptr := v_1.Args[0]
2743 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
2744 break
2745 }
2746 v.reset(Op386ANDLloadidx4)
2747 v.AuxInt = off1 + off2
2748 v.Aux = mergeSym(sym1, sym2)
2749 v.AddArg(val)
2750 v.AddArg(ptr)
2751 v.AddArg(idx)
2752 v.AddArg(mem)
2753 return true
2754 }
2755 return false
2756 }
2757 func rewriteValue386_Op386ANDLloadidx4_0(v *Value) bool {
2758 b := v.Block
2759 config := b.Func.Config
2760
2761
2762
2763 for {
2764 off1 := v.AuxInt
2765 sym := v.Aux
2766 mem := v.Args[3]
2767 val := v.Args[0]
2768 v_1 := v.Args[1]
2769 if v_1.Op != Op386ADDLconst {
2770 break
2771 }
2772 off2 := v_1.AuxInt
2773 base := v_1.Args[0]
2774 idx := v.Args[2]
2775 if !(is32Bit(off1 + off2)) {
2776 break
2777 }
2778 v.reset(Op386ANDLloadidx4)
2779 v.AuxInt = off1 + off2
2780 v.Aux = sym
2781 v.AddArg(val)
2782 v.AddArg(base)
2783 v.AddArg(idx)
2784 v.AddArg(mem)
2785 return true
2786 }
2787
2788
2789
2790 for {
2791 off1 := v.AuxInt
2792 sym := v.Aux
2793 mem := v.Args[3]
2794 val := v.Args[0]
2795 base := v.Args[1]
2796 v_2 := v.Args[2]
2797 if v_2.Op != Op386ADDLconst {
2798 break
2799 }
2800 off2 := v_2.AuxInt
2801 idx := v_2.Args[0]
2802 if !(is32Bit(off1 + off2*4)) {
2803 break
2804 }
2805 v.reset(Op386ANDLloadidx4)
2806 v.AuxInt = off1 + off2*4
2807 v.Aux = sym
2808 v.AddArg(val)
2809 v.AddArg(base)
2810 v.AddArg(idx)
2811 v.AddArg(mem)
2812 return true
2813 }
2814
2815
2816
2817 for {
2818 off1 := v.AuxInt
2819 sym1 := v.Aux
2820 mem := v.Args[3]
2821 val := v.Args[0]
2822 v_1 := v.Args[1]
2823 if v_1.Op != Op386LEAL {
2824 break
2825 }
2826 off2 := v_1.AuxInt
2827 sym2 := v_1.Aux
2828 base := v_1.Args[0]
2829 idx := v.Args[2]
2830 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
2831 break
2832 }
2833 v.reset(Op386ANDLloadidx4)
2834 v.AuxInt = off1 + off2
2835 v.Aux = mergeSym(sym1, sym2)
2836 v.AddArg(val)
2837 v.AddArg(base)
2838 v.AddArg(idx)
2839 v.AddArg(mem)
2840 return true
2841 }
2842 return false
2843 }
2844 func rewriteValue386_Op386ANDLmodify_0(v *Value) bool {
2845 b := v.Block
2846 config := b.Func.Config
2847
2848
2849
2850 for {
2851 off1 := v.AuxInt
2852 sym := v.Aux
2853 mem := v.Args[2]
2854 v_0 := v.Args[0]
2855 if v_0.Op != Op386ADDLconst {
2856 break
2857 }
2858 off2 := v_0.AuxInt
2859 base := v_0.Args[0]
2860 val := v.Args[1]
2861 if !(is32Bit(off1 + off2)) {
2862 break
2863 }
2864 v.reset(Op386ANDLmodify)
2865 v.AuxInt = off1 + off2
2866 v.Aux = sym
2867 v.AddArg(base)
2868 v.AddArg(val)
2869 v.AddArg(mem)
2870 return true
2871 }
2872
2873
2874
2875 for {
2876 off1 := v.AuxInt
2877 sym1 := v.Aux
2878 mem := v.Args[2]
2879 v_0 := v.Args[0]
2880 if v_0.Op != Op386LEAL {
2881 break
2882 }
2883 off2 := v_0.AuxInt
2884 sym2 := v_0.Aux
2885 base := v_0.Args[0]
2886 val := v.Args[1]
2887 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
2888 break
2889 }
2890 v.reset(Op386ANDLmodify)
2891 v.AuxInt = off1 + off2
2892 v.Aux = mergeSym(sym1, sym2)
2893 v.AddArg(base)
2894 v.AddArg(val)
2895 v.AddArg(mem)
2896 return true
2897 }
2898 return false
2899 }
2900 func rewriteValue386_Op386ANDLmodifyidx4_0(v *Value) bool {
2901 b := v.Block
2902 config := b.Func.Config
2903
2904
2905
2906 for {
2907 off1 := v.AuxInt
2908 sym := v.Aux
2909 mem := v.Args[3]
2910 v_0 := v.Args[0]
2911 if v_0.Op != Op386ADDLconst {
2912 break
2913 }
2914 off2 := v_0.AuxInt
2915 base := v_0.Args[0]
2916 idx := v.Args[1]
2917 val := v.Args[2]
2918 if !(is32Bit(off1 + off2)) {
2919 break
2920 }
2921 v.reset(Op386ANDLmodifyidx4)
2922 v.AuxInt = off1 + off2
2923 v.Aux = sym
2924 v.AddArg(base)
2925 v.AddArg(idx)
2926 v.AddArg(val)
2927 v.AddArg(mem)
2928 return true
2929 }
2930
2931
2932
2933 for {
2934 off1 := v.AuxInt
2935 sym := v.Aux
2936 mem := v.Args[3]
2937 base := v.Args[0]
2938 v_1 := v.Args[1]
2939 if v_1.Op != Op386ADDLconst {
2940 break
2941 }
2942 off2 := v_1.AuxInt
2943 idx := v_1.Args[0]
2944 val := v.Args[2]
2945 if !(is32Bit(off1 + off2*4)) {
2946 break
2947 }
2948 v.reset(Op386ANDLmodifyidx4)
2949 v.AuxInt = off1 + off2*4
2950 v.Aux = sym
2951 v.AddArg(base)
2952 v.AddArg(idx)
2953 v.AddArg(val)
2954 v.AddArg(mem)
2955 return true
2956 }
2957
2958
2959
2960 for {
2961 off1 := v.AuxInt
2962 sym1 := v.Aux
2963 mem := v.Args[3]
2964 v_0 := v.Args[0]
2965 if v_0.Op != Op386LEAL {
2966 break
2967 }
2968 off2 := v_0.AuxInt
2969 sym2 := v_0.Aux
2970 base := v_0.Args[0]
2971 idx := v.Args[1]
2972 val := v.Args[2]
2973 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
2974 break
2975 }
2976 v.reset(Op386ANDLmodifyidx4)
2977 v.AuxInt = off1 + off2
2978 v.Aux = mergeSym(sym1, sym2)
2979 v.AddArg(base)
2980 v.AddArg(idx)
2981 v.AddArg(val)
2982 v.AddArg(mem)
2983 return true
2984 }
2985
2986
2987
2988 for {
2989 off := v.AuxInt
2990 sym := v.Aux
2991 mem := v.Args[3]
2992 ptr := v.Args[0]
2993 idx := v.Args[1]
2994 v_2 := v.Args[2]
2995 if v_2.Op != Op386MOVLconst {
2996 break
2997 }
2998 c := v_2.AuxInt
2999 if !(validValAndOff(c, off)) {
3000 break
3001 }
3002 v.reset(Op386ANDLconstmodifyidx4)
3003 v.AuxInt = makeValAndOff(c, off)
3004 v.Aux = sym
3005 v.AddArg(ptr)
3006 v.AddArg(idx)
3007 v.AddArg(mem)
3008 return true
3009 }
3010 return false
3011 }
3012 func rewriteValue386_Op386CMPB_0(v *Value) bool {
3013 b := v.Block
3014
3015
3016
3017 for {
3018 _ = v.Args[1]
3019 x := v.Args[0]
3020 v_1 := v.Args[1]
3021 if v_1.Op != Op386MOVLconst {
3022 break
3023 }
3024 c := v_1.AuxInt
3025 v.reset(Op386CMPBconst)
3026 v.AuxInt = int64(int8(c))
3027 v.AddArg(x)
3028 return true
3029 }
3030
3031
3032
3033 for {
3034 x := v.Args[1]
3035 v_0 := v.Args[0]
3036 if v_0.Op != Op386MOVLconst {
3037 break
3038 }
3039 c := v_0.AuxInt
3040 v.reset(Op386InvertFlags)
3041 v0 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
3042 v0.AuxInt = int64(int8(c))
3043 v0.AddArg(x)
3044 v.AddArg(v0)
3045 return true
3046 }
3047
3048
3049
3050 for {
3051 x := v.Args[1]
3052 l := v.Args[0]
3053 if l.Op != Op386MOVBload {
3054 break
3055 }
3056 off := l.AuxInt
3057 sym := l.Aux
3058 mem := l.Args[1]
3059 ptr := l.Args[0]
3060 if !(canMergeLoad(v, l) && clobber(l)) {
3061 break
3062 }
3063 v.reset(Op386CMPBload)
3064 v.AuxInt = off
3065 v.Aux = sym
3066 v.AddArg(ptr)
3067 v.AddArg(x)
3068 v.AddArg(mem)
3069 return true
3070 }
3071
3072
3073
3074 for {
3075 _ = v.Args[1]
3076 x := v.Args[0]
3077 l := v.Args[1]
3078 if l.Op != Op386MOVBload {
3079 break
3080 }
3081 off := l.AuxInt
3082 sym := l.Aux
3083 mem := l.Args[1]
3084 ptr := l.Args[0]
3085 if !(canMergeLoad(v, l) && clobber(l)) {
3086 break
3087 }
3088 v.reset(Op386InvertFlags)
3089 v0 := b.NewValue0(l.Pos, Op386CMPBload, types.TypeFlags)
3090 v0.AuxInt = off
3091 v0.Aux = sym
3092 v0.AddArg(ptr)
3093 v0.AddArg(x)
3094 v0.AddArg(mem)
3095 v.AddArg(v0)
3096 return true
3097 }
3098 return false
3099 }
3100 func rewriteValue386_Op386CMPBconst_0(v *Value) bool {
3101 b := v.Block
3102
3103
3104
3105 for {
3106 y := v.AuxInt
3107 v_0 := v.Args[0]
3108 if v_0.Op != Op386MOVLconst {
3109 break
3110 }
3111 x := v_0.AuxInt
3112 if !(int8(x) == int8(y)) {
3113 break
3114 }
3115 v.reset(Op386FlagEQ)
3116 return true
3117 }
3118
3119
3120
3121 for {
3122 y := v.AuxInt
3123 v_0 := v.Args[0]
3124 if v_0.Op != Op386MOVLconst {
3125 break
3126 }
3127 x := v_0.AuxInt
3128 if !(int8(x) < int8(y) && uint8(x) < uint8(y)) {
3129 break
3130 }
3131 v.reset(Op386FlagLT_ULT)
3132 return true
3133 }
3134
3135
3136
3137 for {
3138 y := v.AuxInt
3139 v_0 := v.Args[0]
3140 if v_0.Op != Op386MOVLconst {
3141 break
3142 }
3143 x := v_0.AuxInt
3144 if !(int8(x) < int8(y) && uint8(x) > uint8(y)) {
3145 break
3146 }
3147 v.reset(Op386FlagLT_UGT)
3148 return true
3149 }
3150
3151
3152
3153 for {
3154 y := v.AuxInt
3155 v_0 := v.Args[0]
3156 if v_0.Op != Op386MOVLconst {
3157 break
3158 }
3159 x := v_0.AuxInt
3160 if !(int8(x) > int8(y) && uint8(x) < uint8(y)) {
3161 break
3162 }
3163 v.reset(Op386FlagGT_ULT)
3164 return true
3165 }
3166
3167
3168
3169 for {
3170 y := v.AuxInt
3171 v_0 := v.Args[0]
3172 if v_0.Op != Op386MOVLconst {
3173 break
3174 }
3175 x := v_0.AuxInt
3176 if !(int8(x) > int8(y) && uint8(x) > uint8(y)) {
3177 break
3178 }
3179 v.reset(Op386FlagGT_UGT)
3180 return true
3181 }
3182
3183
3184
3185 for {
3186 n := v.AuxInt
3187 v_0 := v.Args[0]
3188 if v_0.Op != Op386ANDLconst {
3189 break
3190 }
3191 m := v_0.AuxInt
3192 if !(0 <= int8(m) && int8(m) < int8(n)) {
3193 break
3194 }
3195 v.reset(Op386FlagLT_ULT)
3196 return true
3197 }
3198
3199
3200
3201 for {
3202 if v.AuxInt != 0 {
3203 break
3204 }
3205 l := v.Args[0]
3206 if l.Op != Op386ANDL {
3207 break
3208 }
3209 y := l.Args[1]
3210 x := l.Args[0]
3211 if !(l.Uses == 1) {
3212 break
3213 }
3214 v.reset(Op386TESTB)
3215 v.AddArg(x)
3216 v.AddArg(y)
3217 return true
3218 }
3219
3220
3221
3222 for {
3223 if v.AuxInt != 0 {
3224 break
3225 }
3226 l := v.Args[0]
3227 if l.Op != Op386ANDLconst {
3228 break
3229 }
3230 c := l.AuxInt
3231 x := l.Args[0]
3232 if !(l.Uses == 1) {
3233 break
3234 }
3235 v.reset(Op386TESTBconst)
3236 v.AuxInt = int64(int8(c))
3237 v.AddArg(x)
3238 return true
3239 }
3240
3241
3242
3243 for {
3244 if v.AuxInt != 0 {
3245 break
3246 }
3247 x := v.Args[0]
3248 v.reset(Op386TESTB)
3249 v.AddArg(x)
3250 v.AddArg(x)
3251 return true
3252 }
3253
3254
3255
3256 for {
3257 c := v.AuxInt
3258 l := v.Args[0]
3259 if l.Op != Op386MOVBload {
3260 break
3261 }
3262 off := l.AuxInt
3263 sym := l.Aux
3264 mem := l.Args[1]
3265 ptr := l.Args[0]
3266 if !(l.Uses == 1 && validValAndOff(c, off) && clobber(l)) {
3267 break
3268 }
3269 b = l.Block
3270 v0 := b.NewValue0(l.Pos, Op386CMPBconstload, types.TypeFlags)
3271 v.reset(OpCopy)
3272 v.AddArg(v0)
3273 v0.AuxInt = makeValAndOff(c, off)
3274 v0.Aux = sym
3275 v0.AddArg(ptr)
3276 v0.AddArg(mem)
3277 return true
3278 }
3279 return false
3280 }
3281 func rewriteValue386_Op386CMPBload_0(v *Value) bool {
3282
3283
3284
3285 for {
3286 off := v.AuxInt
3287 sym := v.Aux
3288 mem := v.Args[2]
3289 ptr := v.Args[0]
3290 v_1 := v.Args[1]
3291 if v_1.Op != Op386MOVLconst {
3292 break
3293 }
3294 c := v_1.AuxInt
3295 if !(validValAndOff(int64(int8(c)), off)) {
3296 break
3297 }
3298 v.reset(Op386CMPBconstload)
3299 v.AuxInt = makeValAndOff(int64(int8(c)), off)
3300 v.Aux = sym
3301 v.AddArg(ptr)
3302 v.AddArg(mem)
3303 return true
3304 }
3305 return false
3306 }
3307 func rewriteValue386_Op386CMPL_0(v *Value) bool {
3308 b := v.Block
3309
3310
3311
3312 for {
3313 _ = v.Args[1]
3314 x := v.Args[0]
3315 v_1 := v.Args[1]
3316 if v_1.Op != Op386MOVLconst {
3317 break
3318 }
3319 c := v_1.AuxInt
3320 v.reset(Op386CMPLconst)
3321 v.AuxInt = c
3322 v.AddArg(x)
3323 return true
3324 }
3325
3326
3327
3328 for {
3329 x := v.Args[1]
3330 v_0 := v.Args[0]
3331 if v_0.Op != Op386MOVLconst {
3332 break
3333 }
3334 c := v_0.AuxInt
3335 v.reset(Op386InvertFlags)
3336 v0 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
3337 v0.AuxInt = c
3338 v0.AddArg(x)
3339 v.AddArg(v0)
3340 return true
3341 }
3342
3343
3344
3345 for {
3346 x := v.Args[1]
3347 l := v.Args[0]
3348 if l.Op != Op386MOVLload {
3349 break
3350 }
3351 off := l.AuxInt
3352 sym := l.Aux
3353 mem := l.Args[1]
3354 ptr := l.Args[0]
3355 if !(canMergeLoad(v, l) && clobber(l)) {
3356 break
3357 }
3358 v.reset(Op386CMPLload)
3359 v.AuxInt = off
3360 v.Aux = sym
3361 v.AddArg(ptr)
3362 v.AddArg(x)
3363 v.AddArg(mem)
3364 return true
3365 }
3366
3367
3368
3369 for {
3370 _ = v.Args[1]
3371 x := v.Args[0]
3372 l := v.Args[1]
3373 if l.Op != Op386MOVLload {
3374 break
3375 }
3376 off := l.AuxInt
3377 sym := l.Aux
3378 mem := l.Args[1]
3379 ptr := l.Args[0]
3380 if !(canMergeLoad(v, l) && clobber(l)) {
3381 break
3382 }
3383 v.reset(Op386InvertFlags)
3384 v0 := b.NewValue0(l.Pos, Op386CMPLload, types.TypeFlags)
3385 v0.AuxInt = off
3386 v0.Aux = sym
3387 v0.AddArg(ptr)
3388 v0.AddArg(x)
3389 v0.AddArg(mem)
3390 v.AddArg(v0)
3391 return true
3392 }
3393 return false
3394 }
3395 func rewriteValue386_Op386CMPLconst_0(v *Value) bool {
3396
3397
3398
3399 for {
3400 y := v.AuxInt
3401 v_0 := v.Args[0]
3402 if v_0.Op != Op386MOVLconst {
3403 break
3404 }
3405 x := v_0.AuxInt
3406 if !(int32(x) == int32(y)) {
3407 break
3408 }
3409 v.reset(Op386FlagEQ)
3410 return true
3411 }
3412
3413
3414
3415 for {
3416 y := v.AuxInt
3417 v_0 := v.Args[0]
3418 if v_0.Op != Op386MOVLconst {
3419 break
3420 }
3421 x := v_0.AuxInt
3422 if !(int32(x) < int32(y) && uint32(x) < uint32(y)) {
3423 break
3424 }
3425 v.reset(Op386FlagLT_ULT)
3426 return true
3427 }
3428
3429
3430
3431 for {
3432 y := v.AuxInt
3433 v_0 := v.Args[0]
3434 if v_0.Op != Op386MOVLconst {
3435 break
3436 }
3437 x := v_0.AuxInt
3438 if !(int32(x) < int32(y) && uint32(x) > uint32(y)) {
3439 break
3440 }
3441 v.reset(Op386FlagLT_UGT)
3442 return true
3443 }
3444
3445
3446
3447 for {
3448 y := v.AuxInt
3449 v_0 := v.Args[0]
3450 if v_0.Op != Op386MOVLconst {
3451 break
3452 }
3453 x := v_0.AuxInt
3454 if !(int32(x) > int32(y) && uint32(x) < uint32(y)) {
3455 break
3456 }
3457 v.reset(Op386FlagGT_ULT)
3458 return true
3459 }
3460
3461
3462
3463 for {
3464 y := v.AuxInt
3465 v_0 := v.Args[0]
3466 if v_0.Op != Op386MOVLconst {
3467 break
3468 }
3469 x := v_0.AuxInt
3470 if !(int32(x) > int32(y) && uint32(x) > uint32(y)) {
3471 break
3472 }
3473 v.reset(Op386FlagGT_UGT)
3474 return true
3475 }
3476
3477
3478
3479 for {
3480 n := v.AuxInt
3481 v_0 := v.Args[0]
3482 if v_0.Op != Op386SHRLconst {
3483 break
3484 }
3485 c := v_0.AuxInt
3486 if !(0 <= n && 0 < c && c <= 32 && (1<<uint64(32-c)) <= uint64(n)) {
3487 break
3488 }
3489 v.reset(Op386FlagLT_ULT)
3490 return true
3491 }
3492
3493
3494
3495 for {
3496 n := v.AuxInt
3497 v_0 := v.Args[0]
3498 if v_0.Op != Op386ANDLconst {
3499 break
3500 }
3501 m := v_0.AuxInt
3502 if !(0 <= int32(m) && int32(m) < int32(n)) {
3503 break
3504 }
3505 v.reset(Op386FlagLT_ULT)
3506 return true
3507 }
3508
3509
3510
3511 for {
3512 if v.AuxInt != 0 {
3513 break
3514 }
3515 l := v.Args[0]
3516 if l.Op != Op386ANDL {
3517 break
3518 }
3519 y := l.Args[1]
3520 x := l.Args[0]
3521 if !(l.Uses == 1) {
3522 break
3523 }
3524 v.reset(Op386TESTL)
3525 v.AddArg(x)
3526 v.AddArg(y)
3527 return true
3528 }
3529
3530
3531
3532 for {
3533 if v.AuxInt != 0 {
3534 break
3535 }
3536 l := v.Args[0]
3537 if l.Op != Op386ANDLconst {
3538 break
3539 }
3540 c := l.AuxInt
3541 x := l.Args[0]
3542 if !(l.Uses == 1) {
3543 break
3544 }
3545 v.reset(Op386TESTLconst)
3546 v.AuxInt = c
3547 v.AddArg(x)
3548 return true
3549 }
3550
3551
3552
3553 for {
3554 if v.AuxInt != 0 {
3555 break
3556 }
3557 x := v.Args[0]
3558 v.reset(Op386TESTL)
3559 v.AddArg(x)
3560 v.AddArg(x)
3561 return true
3562 }
3563 return false
3564 }
3565 func rewriteValue386_Op386CMPLconst_10(v *Value) bool {
3566 b := v.Block
3567
3568
3569
3570 for {
3571 c := v.AuxInt
3572 l := v.Args[0]
3573 if l.Op != Op386MOVLload {
3574 break
3575 }
3576 off := l.AuxInt
3577 sym := l.Aux
3578 mem := l.Args[1]
3579 ptr := l.Args[0]
3580 if !(l.Uses == 1 && validValAndOff(c, off) && clobber(l)) {
3581 break
3582 }
3583 b = l.Block
3584 v0 := b.NewValue0(l.Pos, Op386CMPLconstload, types.TypeFlags)
3585 v.reset(OpCopy)
3586 v.AddArg(v0)
3587 v0.AuxInt = makeValAndOff(c, off)
3588 v0.Aux = sym
3589 v0.AddArg(ptr)
3590 v0.AddArg(mem)
3591 return true
3592 }
3593 return false
3594 }
3595 func rewriteValue386_Op386CMPLload_0(v *Value) bool {
3596
3597
3598
3599 for {
3600 off := v.AuxInt
3601 sym := v.Aux
3602 mem := v.Args[2]
3603 ptr := v.Args[0]
3604 v_1 := v.Args[1]
3605 if v_1.Op != Op386MOVLconst {
3606 break
3607 }
3608 c := v_1.AuxInt
3609 if !(validValAndOff(int64(int32(c)), off)) {
3610 break
3611 }
3612 v.reset(Op386CMPLconstload)
3613 v.AuxInt = makeValAndOff(int64(int32(c)), off)
3614 v.Aux = sym
3615 v.AddArg(ptr)
3616 v.AddArg(mem)
3617 return true
3618 }
3619 return false
3620 }
3621 func rewriteValue386_Op386CMPW_0(v *Value) bool {
3622 b := v.Block
3623
3624
3625
3626 for {
3627 _ = v.Args[1]
3628 x := v.Args[0]
3629 v_1 := v.Args[1]
3630 if v_1.Op != Op386MOVLconst {
3631 break
3632 }
3633 c := v_1.AuxInt
3634 v.reset(Op386CMPWconst)
3635 v.AuxInt = int64(int16(c))
3636 v.AddArg(x)
3637 return true
3638 }
3639
3640
3641
3642 for {
3643 x := v.Args[1]
3644 v_0 := v.Args[0]
3645 if v_0.Op != Op386MOVLconst {
3646 break
3647 }
3648 c := v_0.AuxInt
3649 v.reset(Op386InvertFlags)
3650 v0 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
3651 v0.AuxInt = int64(int16(c))
3652 v0.AddArg(x)
3653 v.AddArg(v0)
3654 return true
3655 }
3656
3657
3658
3659 for {
3660 x := v.Args[1]
3661 l := v.Args[0]
3662 if l.Op != Op386MOVWload {
3663 break
3664 }
3665 off := l.AuxInt
3666 sym := l.Aux
3667 mem := l.Args[1]
3668 ptr := l.Args[0]
3669 if !(canMergeLoad(v, l) && clobber(l)) {
3670 break
3671 }
3672 v.reset(Op386CMPWload)
3673 v.AuxInt = off
3674 v.Aux = sym
3675 v.AddArg(ptr)
3676 v.AddArg(x)
3677 v.AddArg(mem)
3678 return true
3679 }
3680
3681
3682
3683 for {
3684 _ = v.Args[1]
3685 x := v.Args[0]
3686 l := v.Args[1]
3687 if l.Op != Op386MOVWload {
3688 break
3689 }
3690 off := l.AuxInt
3691 sym := l.Aux
3692 mem := l.Args[1]
3693 ptr := l.Args[0]
3694 if !(canMergeLoad(v, l) && clobber(l)) {
3695 break
3696 }
3697 v.reset(Op386InvertFlags)
3698 v0 := b.NewValue0(l.Pos, Op386CMPWload, types.TypeFlags)
3699 v0.AuxInt = off
3700 v0.Aux = sym
3701 v0.AddArg(ptr)
3702 v0.AddArg(x)
3703 v0.AddArg(mem)
3704 v.AddArg(v0)
3705 return true
3706 }
3707 return false
3708 }
3709 func rewriteValue386_Op386CMPWconst_0(v *Value) bool {
3710 b := v.Block
3711
3712
3713
3714 for {
3715 y := v.AuxInt
3716 v_0 := v.Args[0]
3717 if v_0.Op != Op386MOVLconst {
3718 break
3719 }
3720 x := v_0.AuxInt
3721 if !(int16(x) == int16(y)) {
3722 break
3723 }
3724 v.reset(Op386FlagEQ)
3725 return true
3726 }
3727
3728
3729
3730 for {
3731 y := v.AuxInt
3732 v_0 := v.Args[0]
3733 if v_0.Op != Op386MOVLconst {
3734 break
3735 }
3736 x := v_0.AuxInt
3737 if !(int16(x) < int16(y) && uint16(x) < uint16(y)) {
3738 break
3739 }
3740 v.reset(Op386FlagLT_ULT)
3741 return true
3742 }
3743
3744
3745
3746 for {
3747 y := v.AuxInt
3748 v_0 := v.Args[0]
3749 if v_0.Op != Op386MOVLconst {
3750 break
3751 }
3752 x := v_0.AuxInt
3753 if !(int16(x) < int16(y) && uint16(x) > uint16(y)) {
3754 break
3755 }
3756 v.reset(Op386FlagLT_UGT)
3757 return true
3758 }
3759
3760
3761
3762 for {
3763 y := v.AuxInt
3764 v_0 := v.Args[0]
3765 if v_0.Op != Op386MOVLconst {
3766 break
3767 }
3768 x := v_0.AuxInt
3769 if !(int16(x) > int16(y) && uint16(x) < uint16(y)) {
3770 break
3771 }
3772 v.reset(Op386FlagGT_ULT)
3773 return true
3774 }
3775
3776
3777
3778 for {
3779 y := v.AuxInt
3780 v_0 := v.Args[0]
3781 if v_0.Op != Op386MOVLconst {
3782 break
3783 }
3784 x := v_0.AuxInt
3785 if !(int16(x) > int16(y) && uint16(x) > uint16(y)) {
3786 break
3787 }
3788 v.reset(Op386FlagGT_UGT)
3789 return true
3790 }
3791
3792
3793
3794 for {
3795 n := v.AuxInt
3796 v_0 := v.Args[0]
3797 if v_0.Op != Op386ANDLconst {
3798 break
3799 }
3800 m := v_0.AuxInt
3801 if !(0 <= int16(m) && int16(m) < int16(n)) {
3802 break
3803 }
3804 v.reset(Op386FlagLT_ULT)
3805 return true
3806 }
3807
3808
3809
3810 for {
3811 if v.AuxInt != 0 {
3812 break
3813 }
3814 l := v.Args[0]
3815 if l.Op != Op386ANDL {
3816 break
3817 }
3818 y := l.Args[1]
3819 x := l.Args[0]
3820 if !(l.Uses == 1) {
3821 break
3822 }
3823 v.reset(Op386TESTW)
3824 v.AddArg(x)
3825 v.AddArg(y)
3826 return true
3827 }
3828
3829
3830
3831 for {
3832 if v.AuxInt != 0 {
3833 break
3834 }
3835 l := v.Args[0]
3836 if l.Op != Op386ANDLconst {
3837 break
3838 }
3839 c := l.AuxInt
3840 x := l.Args[0]
3841 if !(l.Uses == 1) {
3842 break
3843 }
3844 v.reset(Op386TESTWconst)
3845 v.AuxInt = int64(int16(c))
3846 v.AddArg(x)
3847 return true
3848 }
3849
3850
3851
3852 for {
3853 if v.AuxInt != 0 {
3854 break
3855 }
3856 x := v.Args[0]
3857 v.reset(Op386TESTW)
3858 v.AddArg(x)
3859 v.AddArg(x)
3860 return true
3861 }
3862
3863
3864
3865 for {
3866 c := v.AuxInt
3867 l := v.Args[0]
3868 if l.Op != Op386MOVWload {
3869 break
3870 }
3871 off := l.AuxInt
3872 sym := l.Aux
3873 mem := l.Args[1]
3874 ptr := l.Args[0]
3875 if !(l.Uses == 1 && validValAndOff(c, off) && clobber(l)) {
3876 break
3877 }
3878 b = l.Block
3879 v0 := b.NewValue0(l.Pos, Op386CMPWconstload, types.TypeFlags)
3880 v.reset(OpCopy)
3881 v.AddArg(v0)
3882 v0.AuxInt = makeValAndOff(c, off)
3883 v0.Aux = sym
3884 v0.AddArg(ptr)
3885 v0.AddArg(mem)
3886 return true
3887 }
3888 return false
3889 }
3890 func rewriteValue386_Op386CMPWload_0(v *Value) bool {
3891
3892
3893
3894 for {
3895 off := v.AuxInt
3896 sym := v.Aux
3897 mem := v.Args[2]
3898 ptr := v.Args[0]
3899 v_1 := v.Args[1]
3900 if v_1.Op != Op386MOVLconst {
3901 break
3902 }
3903 c := v_1.AuxInt
3904 if !(validValAndOff(int64(int16(c)), off)) {
3905 break
3906 }
3907 v.reset(Op386CMPWconstload)
3908 v.AuxInt = makeValAndOff(int64(int16(c)), off)
3909 v.Aux = sym
3910 v.AddArg(ptr)
3911 v.AddArg(mem)
3912 return true
3913 }
3914 return false
3915 }
3916 func rewriteValue386_Op386DIVSD_0(v *Value) bool {
3917 b := v.Block
3918 config := b.Func.Config
3919
3920
3921
3922 for {
3923 _ = v.Args[1]
3924 x := v.Args[0]
3925 l := v.Args[1]
3926 if l.Op != Op386MOVSDload {
3927 break
3928 }
3929 off := l.AuxInt
3930 sym := l.Aux
3931 mem := l.Args[1]
3932 ptr := l.Args[0]
3933 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
3934 break
3935 }
3936 v.reset(Op386DIVSDload)
3937 v.AuxInt = off
3938 v.Aux = sym
3939 v.AddArg(x)
3940 v.AddArg(ptr)
3941 v.AddArg(mem)
3942 return true
3943 }
3944 return false
3945 }
3946 func rewriteValue386_Op386DIVSDload_0(v *Value) bool {
3947 b := v.Block
3948 config := b.Func.Config
3949
3950
3951
3952 for {
3953 off1 := v.AuxInt
3954 sym := v.Aux
3955 mem := v.Args[2]
3956 val := v.Args[0]
3957 v_1 := v.Args[1]
3958 if v_1.Op != Op386ADDLconst {
3959 break
3960 }
3961 off2 := v_1.AuxInt
3962 base := v_1.Args[0]
3963 if !(is32Bit(off1 + off2)) {
3964 break
3965 }
3966 v.reset(Op386DIVSDload)
3967 v.AuxInt = off1 + off2
3968 v.Aux = sym
3969 v.AddArg(val)
3970 v.AddArg(base)
3971 v.AddArg(mem)
3972 return true
3973 }
3974
3975
3976
3977 for {
3978 off1 := v.AuxInt
3979 sym1 := v.Aux
3980 mem := v.Args[2]
3981 val := v.Args[0]
3982 v_1 := v.Args[1]
3983 if v_1.Op != Op386LEAL {
3984 break
3985 }
3986 off2 := v_1.AuxInt
3987 sym2 := v_1.Aux
3988 base := v_1.Args[0]
3989 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
3990 break
3991 }
3992 v.reset(Op386DIVSDload)
3993 v.AuxInt = off1 + off2
3994 v.Aux = mergeSym(sym1, sym2)
3995 v.AddArg(val)
3996 v.AddArg(base)
3997 v.AddArg(mem)
3998 return true
3999 }
4000 return false
4001 }
4002 func rewriteValue386_Op386DIVSS_0(v *Value) bool {
4003 b := v.Block
4004 config := b.Func.Config
4005
4006
4007
4008 for {
4009 _ = v.Args[1]
4010 x := v.Args[0]
4011 l := v.Args[1]
4012 if l.Op != Op386MOVSSload {
4013 break
4014 }
4015 off := l.AuxInt
4016 sym := l.Aux
4017 mem := l.Args[1]
4018 ptr := l.Args[0]
4019 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
4020 break
4021 }
4022 v.reset(Op386DIVSSload)
4023 v.AuxInt = off
4024 v.Aux = sym
4025 v.AddArg(x)
4026 v.AddArg(ptr)
4027 v.AddArg(mem)
4028 return true
4029 }
4030 return false
4031 }
4032 func rewriteValue386_Op386DIVSSload_0(v *Value) bool {
4033 b := v.Block
4034 config := b.Func.Config
4035
4036
4037
4038 for {
4039 off1 := v.AuxInt
4040 sym := v.Aux
4041 mem := v.Args[2]
4042 val := v.Args[0]
4043 v_1 := v.Args[1]
4044 if v_1.Op != Op386ADDLconst {
4045 break
4046 }
4047 off2 := v_1.AuxInt
4048 base := v_1.Args[0]
4049 if !(is32Bit(off1 + off2)) {
4050 break
4051 }
4052 v.reset(Op386DIVSSload)
4053 v.AuxInt = off1 + off2
4054 v.Aux = sym
4055 v.AddArg(val)
4056 v.AddArg(base)
4057 v.AddArg(mem)
4058 return true
4059 }
4060
4061
4062
4063 for {
4064 off1 := v.AuxInt
4065 sym1 := v.Aux
4066 mem := v.Args[2]
4067 val := v.Args[0]
4068 v_1 := v.Args[1]
4069 if v_1.Op != Op386LEAL {
4070 break
4071 }
4072 off2 := v_1.AuxInt
4073 sym2 := v_1.Aux
4074 base := v_1.Args[0]
4075 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
4076 break
4077 }
4078 v.reset(Op386DIVSSload)
4079 v.AuxInt = off1 + off2
4080 v.Aux = mergeSym(sym1, sym2)
4081 v.AddArg(val)
4082 v.AddArg(base)
4083 v.AddArg(mem)
4084 return true
4085 }
4086 return false
4087 }
4088 func rewriteValue386_Op386LEAL_0(v *Value) bool {
4089
4090
4091
4092 for {
4093 c := v.AuxInt
4094 s := v.Aux
4095 v_0 := v.Args[0]
4096 if v_0.Op != Op386ADDLconst {
4097 break
4098 }
4099 d := v_0.AuxInt
4100 x := v_0.Args[0]
4101 if !(is32Bit(c + d)) {
4102 break
4103 }
4104 v.reset(Op386LEAL)
4105 v.AuxInt = c + d
4106 v.Aux = s
4107 v.AddArg(x)
4108 return true
4109 }
4110
4111
4112
4113 for {
4114 c := v.AuxInt
4115 s := v.Aux
4116 v_0 := v.Args[0]
4117 if v_0.Op != Op386ADDL {
4118 break
4119 }
4120 y := v_0.Args[1]
4121 x := v_0.Args[0]
4122 if !(x.Op != OpSB && y.Op != OpSB) {
4123 break
4124 }
4125 v.reset(Op386LEAL1)
4126 v.AuxInt = c
4127 v.Aux = s
4128 v.AddArg(x)
4129 v.AddArg(y)
4130 return true
4131 }
4132
4133
4134
4135 for {
4136 off1 := v.AuxInt
4137 sym1 := v.Aux
4138 v_0 := v.Args[0]
4139 if v_0.Op != Op386LEAL {
4140 break
4141 }
4142 off2 := v_0.AuxInt
4143 sym2 := v_0.Aux
4144 x := v_0.Args[0]
4145 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
4146 break
4147 }
4148 v.reset(Op386LEAL)
4149 v.AuxInt = off1 + off2
4150 v.Aux = mergeSym(sym1, sym2)
4151 v.AddArg(x)
4152 return true
4153 }
4154
4155
4156
4157 for {
4158 off1 := v.AuxInt
4159 sym1 := v.Aux
4160 v_0 := v.Args[0]
4161 if v_0.Op != Op386LEAL1 {
4162 break
4163 }
4164 off2 := v_0.AuxInt
4165 sym2 := v_0.Aux
4166 y := v_0.Args[1]
4167 x := v_0.Args[0]
4168 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
4169 break
4170 }
4171 v.reset(Op386LEAL1)
4172 v.AuxInt = off1 + off2
4173 v.Aux = mergeSym(sym1, sym2)
4174 v.AddArg(x)
4175 v.AddArg(y)
4176 return true
4177 }
4178
4179
4180
4181 for {
4182 off1 := v.AuxInt
4183 sym1 := v.Aux
4184 v_0 := v.Args[0]
4185 if v_0.Op != Op386LEAL2 {
4186 break
4187 }
4188 off2 := v_0.AuxInt
4189 sym2 := v_0.Aux
4190 y := v_0.Args[1]
4191 x := v_0.Args[0]
4192 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
4193 break
4194 }
4195 v.reset(Op386LEAL2)
4196 v.AuxInt = off1 + off2
4197 v.Aux = mergeSym(sym1, sym2)
4198 v.AddArg(x)
4199 v.AddArg(y)
4200 return true
4201 }
4202
4203
4204
4205 for {
4206 off1 := v.AuxInt
4207 sym1 := v.Aux
4208 v_0 := v.Args[0]
4209 if v_0.Op != Op386LEAL4 {
4210 break
4211 }
4212 off2 := v_0.AuxInt
4213 sym2 := v_0.Aux
4214 y := v_0.Args[1]
4215 x := v_0.Args[0]
4216 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
4217 break
4218 }
4219 v.reset(Op386LEAL4)
4220 v.AuxInt = off1 + off2
4221 v.Aux = mergeSym(sym1, sym2)
4222 v.AddArg(x)
4223 v.AddArg(y)
4224 return true
4225 }
4226
4227
4228
4229 for {
4230 off1 := v.AuxInt
4231 sym1 := v.Aux
4232 v_0 := v.Args[0]
4233 if v_0.Op != Op386LEAL8 {
4234 break
4235 }
4236 off2 := v_0.AuxInt
4237 sym2 := v_0.Aux
4238 y := v_0.Args[1]
4239 x := v_0.Args[0]
4240 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
4241 break
4242 }
4243 v.reset(Op386LEAL8)
4244 v.AuxInt = off1 + off2
4245 v.Aux = mergeSym(sym1, sym2)
4246 v.AddArg(x)
4247 v.AddArg(y)
4248 return true
4249 }
4250 return false
4251 }
4252 func rewriteValue386_Op386LEAL1_0(v *Value) bool {
4253
4254
4255
4256 for {
4257 c := v.AuxInt
4258 s := v.Aux
4259 y := v.Args[1]
4260 v_0 := v.Args[0]
4261 if v_0.Op != Op386ADDLconst {
4262 break
4263 }
4264 d := v_0.AuxInt
4265 x := v_0.Args[0]
4266 if !(is32Bit(c+d) && x.Op != OpSB) {
4267 break
4268 }
4269 v.reset(Op386LEAL1)
4270 v.AuxInt = c + d
4271 v.Aux = s
4272 v.AddArg(x)
4273 v.AddArg(y)
4274 return true
4275 }
4276
4277
4278
4279 for {
4280 c := v.AuxInt
4281 s := v.Aux
4282 _ = v.Args[1]
4283 y := v.Args[0]
4284 v_1 := v.Args[1]
4285 if v_1.Op != Op386ADDLconst {
4286 break
4287 }
4288 d := v_1.AuxInt
4289 x := v_1.Args[0]
4290 if !(is32Bit(c+d) && x.Op != OpSB) {
4291 break
4292 }
4293 v.reset(Op386LEAL1)
4294 v.AuxInt = c + d
4295 v.Aux = s
4296 v.AddArg(x)
4297 v.AddArg(y)
4298 return true
4299 }
4300
4301
4302
4303 for {
4304 c := v.AuxInt
4305 s := v.Aux
4306 _ = v.Args[1]
4307 x := v.Args[0]
4308 v_1 := v.Args[1]
4309 if v_1.Op != Op386SHLLconst {
4310 break
4311 }
4312 if v_1.AuxInt != 1 {
4313 break
4314 }
4315 y := v_1.Args[0]
4316 v.reset(Op386LEAL2)
4317 v.AuxInt = c
4318 v.Aux = s
4319 v.AddArg(x)
4320 v.AddArg(y)
4321 return true
4322 }
4323
4324
4325
4326 for {
4327 c := v.AuxInt
4328 s := v.Aux
4329 x := v.Args[1]
4330 v_0 := v.Args[0]
4331 if v_0.Op != Op386SHLLconst {
4332 break
4333 }
4334 if v_0.AuxInt != 1 {
4335 break
4336 }
4337 y := v_0.Args[0]
4338 v.reset(Op386LEAL2)
4339 v.AuxInt = c
4340 v.Aux = s
4341 v.AddArg(x)
4342 v.AddArg(y)
4343 return true
4344 }
4345
4346
4347
4348 for {
4349 c := v.AuxInt
4350 s := v.Aux
4351 _ = v.Args[1]
4352 x := v.Args[0]
4353 v_1 := v.Args[1]
4354 if v_1.Op != Op386SHLLconst {
4355 break
4356 }
4357 if v_1.AuxInt != 2 {
4358 break
4359 }
4360 y := v_1.Args[0]
4361 v.reset(Op386LEAL4)
4362 v.AuxInt = c
4363 v.Aux = s
4364 v.AddArg(x)
4365 v.AddArg(y)
4366 return true
4367 }
4368
4369
4370
4371 for {
4372 c := v.AuxInt
4373 s := v.Aux
4374 x := v.Args[1]
4375 v_0 := v.Args[0]
4376 if v_0.Op != Op386SHLLconst {
4377 break
4378 }
4379 if v_0.AuxInt != 2 {
4380 break
4381 }
4382 y := v_0.Args[0]
4383 v.reset(Op386LEAL4)
4384 v.AuxInt = c
4385 v.Aux = s
4386 v.AddArg(x)
4387 v.AddArg(y)
4388 return true
4389 }
4390
4391
4392
4393 for {
4394 c := v.AuxInt
4395 s := v.Aux
4396 _ = v.Args[1]
4397 x := v.Args[0]
4398 v_1 := v.Args[1]
4399 if v_1.Op != Op386SHLLconst {
4400 break
4401 }
4402 if v_1.AuxInt != 3 {
4403 break
4404 }
4405 y := v_1.Args[0]
4406 v.reset(Op386LEAL8)
4407 v.AuxInt = c
4408 v.Aux = s
4409 v.AddArg(x)
4410 v.AddArg(y)
4411 return true
4412 }
4413
4414
4415
4416 for {
4417 c := v.AuxInt
4418 s := v.Aux
4419 x := v.Args[1]
4420 v_0 := v.Args[0]
4421 if v_0.Op != Op386SHLLconst {
4422 break
4423 }
4424 if v_0.AuxInt != 3 {
4425 break
4426 }
4427 y := v_0.Args[0]
4428 v.reset(Op386LEAL8)
4429 v.AuxInt = c
4430 v.Aux = s
4431 v.AddArg(x)
4432 v.AddArg(y)
4433 return true
4434 }
4435
4436
4437
4438 for {
4439 off1 := v.AuxInt
4440 sym1 := v.Aux
4441 y := v.Args[1]
4442 v_0 := v.Args[0]
4443 if v_0.Op != Op386LEAL {
4444 break
4445 }
4446 off2 := v_0.AuxInt
4447 sym2 := v_0.Aux
4448 x := v_0.Args[0]
4449 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
4450 break
4451 }
4452 v.reset(Op386LEAL1)
4453 v.AuxInt = off1 + off2
4454 v.Aux = mergeSym(sym1, sym2)
4455 v.AddArg(x)
4456 v.AddArg(y)
4457 return true
4458 }
4459
4460
4461
4462 for {
4463 off1 := v.AuxInt
4464 sym1 := v.Aux
4465 _ = v.Args[1]
4466 y := v.Args[0]
4467 v_1 := v.Args[1]
4468 if v_1.Op != Op386LEAL {
4469 break
4470 }
4471 off2 := v_1.AuxInt
4472 sym2 := v_1.Aux
4473 x := v_1.Args[0]
4474 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
4475 break
4476 }
4477 v.reset(Op386LEAL1)
4478 v.AuxInt = off1 + off2
4479 v.Aux = mergeSym(sym1, sym2)
4480 v.AddArg(x)
4481 v.AddArg(y)
4482 return true
4483 }
4484 return false
4485 }
4486 func rewriteValue386_Op386LEAL2_0(v *Value) bool {
4487
4488
4489
4490 for {
4491 c := v.AuxInt
4492 s := v.Aux
4493 y := v.Args[1]
4494 v_0 := v.Args[0]
4495 if v_0.Op != Op386ADDLconst {
4496 break
4497 }
4498 d := v_0.AuxInt
4499 x := v_0.Args[0]
4500 if !(is32Bit(c+d) && x.Op != OpSB) {
4501 break
4502 }
4503 v.reset(Op386LEAL2)
4504 v.AuxInt = c + d
4505 v.Aux = s
4506 v.AddArg(x)
4507 v.AddArg(y)
4508 return true
4509 }
4510
4511
4512
4513 for {
4514 c := v.AuxInt
4515 s := v.Aux
4516 _ = v.Args[1]
4517 x := v.Args[0]
4518 v_1 := v.Args[1]
4519 if v_1.Op != Op386ADDLconst {
4520 break
4521 }
4522 d := v_1.AuxInt
4523 y := v_1.Args[0]
4524 if !(is32Bit(c+2*d) && y.Op != OpSB) {
4525 break
4526 }
4527 v.reset(Op386LEAL2)
4528 v.AuxInt = c + 2*d
4529 v.Aux = s
4530 v.AddArg(x)
4531 v.AddArg(y)
4532 return true
4533 }
4534
4535
4536
4537 for {
4538 c := v.AuxInt
4539 s := v.Aux
4540 _ = v.Args[1]
4541 x := v.Args[0]
4542 v_1 := v.Args[1]
4543 if v_1.Op != Op386SHLLconst {
4544 break
4545 }
4546 if v_1.AuxInt != 1 {
4547 break
4548 }
4549 y := v_1.Args[0]
4550 v.reset(Op386LEAL4)
4551 v.AuxInt = c
4552 v.Aux = s
4553 v.AddArg(x)
4554 v.AddArg(y)
4555 return true
4556 }
4557
4558
4559
4560 for {
4561 c := v.AuxInt
4562 s := v.Aux
4563 _ = v.Args[1]
4564 x := v.Args[0]
4565 v_1 := v.Args[1]
4566 if v_1.Op != Op386SHLLconst {
4567 break
4568 }
4569 if v_1.AuxInt != 2 {
4570 break
4571 }
4572 y := v_1.Args[0]
4573 v.reset(Op386LEAL8)
4574 v.AuxInt = c
4575 v.Aux = s
4576 v.AddArg(x)
4577 v.AddArg(y)
4578 return true
4579 }
4580
4581
4582
4583 for {
4584 off1 := v.AuxInt
4585 sym1 := v.Aux
4586 y := v.Args[1]
4587 v_0 := v.Args[0]
4588 if v_0.Op != Op386LEAL {
4589 break
4590 }
4591 off2 := v_0.AuxInt
4592 sym2 := v_0.Aux
4593 x := v_0.Args[0]
4594 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
4595 break
4596 }
4597 v.reset(Op386LEAL2)
4598 v.AuxInt = off1 + off2
4599 v.Aux = mergeSym(sym1, sym2)
4600 v.AddArg(x)
4601 v.AddArg(y)
4602 return true
4603 }
4604 return false
4605 }
4606 func rewriteValue386_Op386LEAL4_0(v *Value) bool {
4607
4608
4609
4610 for {
4611 c := v.AuxInt
4612 s := v.Aux
4613 y := v.Args[1]
4614 v_0 := v.Args[0]
4615 if v_0.Op != Op386ADDLconst {
4616 break
4617 }
4618 d := v_0.AuxInt
4619 x := v_0.Args[0]
4620 if !(is32Bit(c+d) && x.Op != OpSB) {
4621 break
4622 }
4623 v.reset(Op386LEAL4)
4624 v.AuxInt = c + d
4625 v.Aux = s
4626 v.AddArg(x)
4627 v.AddArg(y)
4628 return true
4629 }
4630
4631
4632
4633 for {
4634 c := v.AuxInt
4635 s := v.Aux
4636 _ = v.Args[1]
4637 x := v.Args[0]
4638 v_1 := v.Args[1]
4639 if v_1.Op != Op386ADDLconst {
4640 break
4641 }
4642 d := v_1.AuxInt
4643 y := v_1.Args[0]
4644 if !(is32Bit(c+4*d) && y.Op != OpSB) {
4645 break
4646 }
4647 v.reset(Op386LEAL4)
4648 v.AuxInt = c + 4*d
4649 v.Aux = s
4650 v.AddArg(x)
4651 v.AddArg(y)
4652 return true
4653 }
4654
4655
4656
4657 for {
4658 c := v.AuxInt
4659 s := v.Aux
4660 _ = v.Args[1]
4661 x := v.Args[0]
4662 v_1 := v.Args[1]
4663 if v_1.Op != Op386SHLLconst {
4664 break
4665 }
4666 if v_1.AuxInt != 1 {
4667 break
4668 }
4669 y := v_1.Args[0]
4670 v.reset(Op386LEAL8)
4671 v.AuxInt = c
4672 v.Aux = s
4673 v.AddArg(x)
4674 v.AddArg(y)
4675 return true
4676 }
4677
4678
4679
4680 for {
4681 off1 := v.AuxInt
4682 sym1 := v.Aux
4683 y := v.Args[1]
4684 v_0 := v.Args[0]
4685 if v_0.Op != Op386LEAL {
4686 break
4687 }
4688 off2 := v_0.AuxInt
4689 sym2 := v_0.Aux
4690 x := v_0.Args[0]
4691 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
4692 break
4693 }
4694 v.reset(Op386LEAL4)
4695 v.AuxInt = off1 + off2
4696 v.Aux = mergeSym(sym1, sym2)
4697 v.AddArg(x)
4698 v.AddArg(y)
4699 return true
4700 }
4701 return false
4702 }
4703 func rewriteValue386_Op386LEAL8_0(v *Value) bool {
4704
4705
4706
4707 for {
4708 c := v.AuxInt
4709 s := v.Aux
4710 y := v.Args[1]
4711 v_0 := v.Args[0]
4712 if v_0.Op != Op386ADDLconst {
4713 break
4714 }
4715 d := v_0.AuxInt
4716 x := v_0.Args[0]
4717 if !(is32Bit(c+d) && x.Op != OpSB) {
4718 break
4719 }
4720 v.reset(Op386LEAL8)
4721 v.AuxInt = c + d
4722 v.Aux = s
4723 v.AddArg(x)
4724 v.AddArg(y)
4725 return true
4726 }
4727
4728
4729
4730 for {
4731 c := v.AuxInt
4732 s := v.Aux
4733 _ = v.Args[1]
4734 x := v.Args[0]
4735 v_1 := v.Args[1]
4736 if v_1.Op != Op386ADDLconst {
4737 break
4738 }
4739 d := v_1.AuxInt
4740 y := v_1.Args[0]
4741 if !(is32Bit(c+8*d) && y.Op != OpSB) {
4742 break
4743 }
4744 v.reset(Op386LEAL8)
4745 v.AuxInt = c + 8*d
4746 v.Aux = s
4747 v.AddArg(x)
4748 v.AddArg(y)
4749 return true
4750 }
4751
4752
4753
4754 for {
4755 off1 := v.AuxInt
4756 sym1 := v.Aux
4757 y := v.Args[1]
4758 v_0 := v.Args[0]
4759 if v_0.Op != Op386LEAL {
4760 break
4761 }
4762 off2 := v_0.AuxInt
4763 sym2 := v_0.Aux
4764 x := v_0.Args[0]
4765 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
4766 break
4767 }
4768 v.reset(Op386LEAL8)
4769 v.AuxInt = off1 + off2
4770 v.Aux = mergeSym(sym1, sym2)
4771 v.AddArg(x)
4772 v.AddArg(y)
4773 return true
4774 }
4775 return false
4776 }
4777 func rewriteValue386_Op386MOVBLSX_0(v *Value) bool {
4778 b := v.Block
4779
4780
4781
4782 for {
4783 x := v.Args[0]
4784 if x.Op != Op386MOVBload {
4785 break
4786 }
4787 off := x.AuxInt
4788 sym := x.Aux
4789 mem := x.Args[1]
4790 ptr := x.Args[0]
4791 if !(x.Uses == 1 && clobber(x)) {
4792 break
4793 }
4794 b = x.Block
4795 v0 := b.NewValue0(x.Pos, Op386MOVBLSXload, v.Type)
4796 v.reset(OpCopy)
4797 v.AddArg(v0)
4798 v0.AuxInt = off
4799 v0.Aux = sym
4800 v0.AddArg(ptr)
4801 v0.AddArg(mem)
4802 return true
4803 }
4804
4805
4806
4807 for {
4808 v_0 := v.Args[0]
4809 if v_0.Op != Op386ANDLconst {
4810 break
4811 }
4812 c := v_0.AuxInt
4813 x := v_0.Args[0]
4814 if !(c&0x80 == 0) {
4815 break
4816 }
4817 v.reset(Op386ANDLconst)
4818 v.AuxInt = c & 0x7f
4819 v.AddArg(x)
4820 return true
4821 }
4822 return false
4823 }
4824 func rewriteValue386_Op386MOVBLSXload_0(v *Value) bool {
4825 b := v.Block
4826 config := b.Func.Config
4827
4828
4829
4830 for {
4831 off := v.AuxInt
4832 sym := v.Aux
4833 _ = v.Args[1]
4834 ptr := v.Args[0]
4835 v_1 := v.Args[1]
4836 if v_1.Op != Op386MOVBstore {
4837 break
4838 }
4839 off2 := v_1.AuxInt
4840 sym2 := v_1.Aux
4841 _ = v_1.Args[2]
4842 ptr2 := v_1.Args[0]
4843 x := v_1.Args[1]
4844 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
4845 break
4846 }
4847 v.reset(Op386MOVBLSX)
4848 v.AddArg(x)
4849 return true
4850 }
4851
4852
4853
4854 for {
4855 off1 := v.AuxInt
4856 sym1 := v.Aux
4857 mem := v.Args[1]
4858 v_0 := v.Args[0]
4859 if v_0.Op != Op386LEAL {
4860 break
4861 }
4862 off2 := v_0.AuxInt
4863 sym2 := v_0.Aux
4864 base := v_0.Args[0]
4865 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
4866 break
4867 }
4868 v.reset(Op386MOVBLSXload)
4869 v.AuxInt = off1 + off2
4870 v.Aux = mergeSym(sym1, sym2)
4871 v.AddArg(base)
4872 v.AddArg(mem)
4873 return true
4874 }
4875 return false
4876 }
4877 func rewriteValue386_Op386MOVBLZX_0(v *Value) bool {
4878 b := v.Block
4879
4880
4881
4882 for {
4883 x := v.Args[0]
4884 if x.Op != Op386MOVBload {
4885 break
4886 }
4887 off := x.AuxInt
4888 sym := x.Aux
4889 mem := x.Args[1]
4890 ptr := x.Args[0]
4891 if !(x.Uses == 1 && clobber(x)) {
4892 break
4893 }
4894 b = x.Block
4895 v0 := b.NewValue0(x.Pos, Op386MOVBload, v.Type)
4896 v.reset(OpCopy)
4897 v.AddArg(v0)
4898 v0.AuxInt = off
4899 v0.Aux = sym
4900 v0.AddArg(ptr)
4901 v0.AddArg(mem)
4902 return true
4903 }
4904
4905
4906
4907 for {
4908 x := v.Args[0]
4909 if x.Op != Op386MOVBloadidx1 {
4910 break
4911 }
4912 off := x.AuxInt
4913 sym := x.Aux
4914 mem := x.Args[2]
4915 ptr := x.Args[0]
4916 idx := x.Args[1]
4917 if !(x.Uses == 1 && clobber(x)) {
4918 break
4919 }
4920 b = x.Block
4921 v0 := b.NewValue0(v.Pos, Op386MOVBloadidx1, v.Type)
4922 v.reset(OpCopy)
4923 v.AddArg(v0)
4924 v0.AuxInt = off
4925 v0.Aux = sym
4926 v0.AddArg(ptr)
4927 v0.AddArg(idx)
4928 v0.AddArg(mem)
4929 return true
4930 }
4931
4932
4933
4934 for {
4935 v_0 := v.Args[0]
4936 if v_0.Op != Op386ANDLconst {
4937 break
4938 }
4939 c := v_0.AuxInt
4940 x := v_0.Args[0]
4941 v.reset(Op386ANDLconst)
4942 v.AuxInt = c & 0xff
4943 v.AddArg(x)
4944 return true
4945 }
4946 return false
4947 }
4948 func rewriteValue386_Op386MOVBload_0(v *Value) bool {
4949 b := v.Block
4950 config := b.Func.Config
4951
4952
4953
4954 for {
4955 off := v.AuxInt
4956 sym := v.Aux
4957 _ = v.Args[1]
4958 ptr := v.Args[0]
4959 v_1 := v.Args[1]
4960 if v_1.Op != Op386MOVBstore {
4961 break
4962 }
4963 off2 := v_1.AuxInt
4964 sym2 := v_1.Aux
4965 _ = v_1.Args[2]
4966 ptr2 := v_1.Args[0]
4967 x := v_1.Args[1]
4968 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
4969 break
4970 }
4971 v.reset(Op386MOVBLZX)
4972 v.AddArg(x)
4973 return true
4974 }
4975
4976
4977
4978 for {
4979 off1 := v.AuxInt
4980 sym := v.Aux
4981 mem := v.Args[1]
4982 v_0 := v.Args[0]
4983 if v_0.Op != Op386ADDLconst {
4984 break
4985 }
4986 off2 := v_0.AuxInt
4987 ptr := v_0.Args[0]
4988 if !(is32Bit(off1 + off2)) {
4989 break
4990 }
4991 v.reset(Op386MOVBload)
4992 v.AuxInt = off1 + off2
4993 v.Aux = sym
4994 v.AddArg(ptr)
4995 v.AddArg(mem)
4996 return true
4997 }
4998
4999
5000
5001 for {
5002 off1 := v.AuxInt
5003 sym1 := v.Aux
5004 mem := v.Args[1]
5005 v_0 := v.Args[0]
5006 if v_0.Op != Op386LEAL {
5007 break
5008 }
5009 off2 := v_0.AuxInt
5010 sym2 := v_0.Aux
5011 base := v_0.Args[0]
5012 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
5013 break
5014 }
5015 v.reset(Op386MOVBload)
5016 v.AuxInt = off1 + off2
5017 v.Aux = mergeSym(sym1, sym2)
5018 v.AddArg(base)
5019 v.AddArg(mem)
5020 return true
5021 }
5022
5023
5024
5025 for {
5026 off1 := v.AuxInt
5027 sym1 := v.Aux
5028 mem := v.Args[1]
5029 v_0 := v.Args[0]
5030 if v_0.Op != Op386LEAL1 {
5031 break
5032 }
5033 off2 := v_0.AuxInt
5034 sym2 := v_0.Aux
5035 idx := v_0.Args[1]
5036 ptr := v_0.Args[0]
5037 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
5038 break
5039 }
5040 v.reset(Op386MOVBloadidx1)
5041 v.AuxInt = off1 + off2
5042 v.Aux = mergeSym(sym1, sym2)
5043 v.AddArg(ptr)
5044 v.AddArg(idx)
5045 v.AddArg(mem)
5046 return true
5047 }
5048
5049
5050
5051 for {
5052 off := v.AuxInt
5053 sym := v.Aux
5054 mem := v.Args[1]
5055 v_0 := v.Args[0]
5056 if v_0.Op != Op386ADDL {
5057 break
5058 }
5059 idx := v_0.Args[1]
5060 ptr := v_0.Args[0]
5061 if !(ptr.Op != OpSB) {
5062 break
5063 }
5064 v.reset(Op386MOVBloadidx1)
5065 v.AuxInt = off
5066 v.Aux = sym
5067 v.AddArg(ptr)
5068 v.AddArg(idx)
5069 v.AddArg(mem)
5070 return true
5071 }
5072
5073
5074
5075 for {
5076 off := v.AuxInt
5077 sym := v.Aux
5078 _ = v.Args[1]
5079 v_0 := v.Args[0]
5080 if v_0.Op != OpSB {
5081 break
5082 }
5083 if !(symIsRO(sym)) {
5084 break
5085 }
5086 v.reset(Op386MOVLconst)
5087 v.AuxInt = int64(read8(sym, off))
5088 return true
5089 }
5090 return false
5091 }
5092 func rewriteValue386_Op386MOVBloadidx1_0(v *Value) bool {
5093
5094
5095
5096 for {
5097 c := v.AuxInt
5098 sym := v.Aux
5099 mem := v.Args[2]
5100 v_0 := v.Args[0]
5101 if v_0.Op != Op386ADDLconst {
5102 break
5103 }
5104 d := v_0.AuxInt
5105 ptr := v_0.Args[0]
5106 idx := v.Args[1]
5107 v.reset(Op386MOVBloadidx1)
5108 v.AuxInt = int64(int32(c + d))
5109 v.Aux = sym
5110 v.AddArg(ptr)
5111 v.AddArg(idx)
5112 v.AddArg(mem)
5113 return true
5114 }
5115
5116
5117
5118 for {
5119 c := v.AuxInt
5120 sym := v.Aux
5121 mem := v.Args[2]
5122 idx := v.Args[0]
5123 v_1 := v.Args[1]
5124 if v_1.Op != Op386ADDLconst {
5125 break
5126 }
5127 d := v_1.AuxInt
5128 ptr := v_1.Args[0]
5129 v.reset(Op386MOVBloadidx1)
5130 v.AuxInt = int64(int32(c + d))
5131 v.Aux = sym
5132 v.AddArg(ptr)
5133 v.AddArg(idx)
5134 v.AddArg(mem)
5135 return true
5136 }
5137
5138
5139
5140 for {
5141 c := v.AuxInt
5142 sym := v.Aux
5143 mem := v.Args[2]
5144 ptr := v.Args[0]
5145 v_1 := v.Args[1]
5146 if v_1.Op != Op386ADDLconst {
5147 break
5148 }
5149 d := v_1.AuxInt
5150 idx := v_1.Args[0]
5151 v.reset(Op386MOVBloadidx1)
5152 v.AuxInt = int64(int32(c + d))
5153 v.Aux = sym
5154 v.AddArg(ptr)
5155 v.AddArg(idx)
5156 v.AddArg(mem)
5157 return true
5158 }
5159
5160
5161
5162 for {
5163 c := v.AuxInt
5164 sym := v.Aux
5165 mem := v.Args[2]
5166 v_0 := v.Args[0]
5167 if v_0.Op != Op386ADDLconst {
5168 break
5169 }
5170 d := v_0.AuxInt
5171 idx := v_0.Args[0]
5172 ptr := v.Args[1]
5173 v.reset(Op386MOVBloadidx1)
5174 v.AuxInt = int64(int32(c + d))
5175 v.Aux = sym
5176 v.AddArg(ptr)
5177 v.AddArg(idx)
5178 v.AddArg(mem)
5179 return true
5180 }
5181 return false
5182 }
5183 func rewriteValue386_Op386MOVBstore_0(v *Value) bool {
5184 b := v.Block
5185 config := b.Func.Config
5186
5187
5188
5189 for {
5190 off := v.AuxInt
5191 sym := v.Aux
5192 mem := v.Args[2]
5193 ptr := v.Args[0]
5194 v_1 := v.Args[1]
5195 if v_1.Op != Op386MOVBLSX {
5196 break
5197 }
5198 x := v_1.Args[0]
5199 v.reset(Op386MOVBstore)
5200 v.AuxInt = off
5201 v.Aux = sym
5202 v.AddArg(ptr)
5203 v.AddArg(x)
5204 v.AddArg(mem)
5205 return true
5206 }
5207
5208
5209
5210 for {
5211 off := v.AuxInt
5212 sym := v.Aux
5213 mem := v.Args[2]
5214 ptr := v.Args[0]
5215 v_1 := v.Args[1]
5216 if v_1.Op != Op386MOVBLZX {
5217 break
5218 }
5219 x := v_1.Args[0]
5220 v.reset(Op386MOVBstore)
5221 v.AuxInt = off
5222 v.Aux = sym
5223 v.AddArg(ptr)
5224 v.AddArg(x)
5225 v.AddArg(mem)
5226 return true
5227 }
5228
5229
5230
5231 for {
5232 off1 := v.AuxInt
5233 sym := v.Aux
5234 mem := v.Args[2]
5235 v_0 := v.Args[0]
5236 if v_0.Op != Op386ADDLconst {
5237 break
5238 }
5239 off2 := v_0.AuxInt
5240 ptr := v_0.Args[0]
5241 val := v.Args[1]
5242 if !(is32Bit(off1 + off2)) {
5243 break
5244 }
5245 v.reset(Op386MOVBstore)
5246 v.AuxInt = off1 + off2
5247 v.Aux = sym
5248 v.AddArg(ptr)
5249 v.AddArg(val)
5250 v.AddArg(mem)
5251 return true
5252 }
5253
5254
5255
5256 for {
5257 off := v.AuxInt
5258 sym := v.Aux
5259 mem := v.Args[2]
5260 ptr := v.Args[0]
5261 v_1 := v.Args[1]
5262 if v_1.Op != Op386MOVLconst {
5263 break
5264 }
5265 c := v_1.AuxInt
5266 if !(validOff(off)) {
5267 break
5268 }
5269 v.reset(Op386MOVBstoreconst)
5270 v.AuxInt = makeValAndOff(int64(int8(c)), off)
5271 v.Aux = sym
5272 v.AddArg(ptr)
5273 v.AddArg(mem)
5274 return true
5275 }
5276
5277
5278
5279 for {
5280 off1 := v.AuxInt
5281 sym1 := v.Aux
5282 mem := v.Args[2]
5283 v_0 := v.Args[0]
5284 if v_0.Op != Op386LEAL {
5285 break
5286 }
5287 off2 := v_0.AuxInt
5288 sym2 := v_0.Aux
5289 base := v_0.Args[0]
5290 val := v.Args[1]
5291 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
5292 break
5293 }
5294 v.reset(Op386MOVBstore)
5295 v.AuxInt = off1 + off2
5296 v.Aux = mergeSym(sym1, sym2)
5297 v.AddArg(base)
5298 v.AddArg(val)
5299 v.AddArg(mem)
5300 return true
5301 }
5302
5303
5304
5305 for {
5306 off1 := v.AuxInt
5307 sym1 := v.Aux
5308 mem := v.Args[2]
5309 v_0 := v.Args[0]
5310 if v_0.Op != Op386LEAL1 {
5311 break
5312 }
5313 off2 := v_0.AuxInt
5314 sym2 := v_0.Aux
5315 idx := v_0.Args[1]
5316 ptr := v_0.Args[0]
5317 val := v.Args[1]
5318 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
5319 break
5320 }
5321 v.reset(Op386MOVBstoreidx1)
5322 v.AuxInt = off1 + off2
5323 v.Aux = mergeSym(sym1, sym2)
5324 v.AddArg(ptr)
5325 v.AddArg(idx)
5326 v.AddArg(val)
5327 v.AddArg(mem)
5328 return true
5329 }
5330
5331
5332
5333 for {
5334 off := v.AuxInt
5335 sym := v.Aux
5336 mem := v.Args[2]
5337 v_0 := v.Args[0]
5338 if v_0.Op != Op386ADDL {
5339 break
5340 }
5341 idx := v_0.Args[1]
5342 ptr := v_0.Args[0]
5343 val := v.Args[1]
5344 if !(ptr.Op != OpSB) {
5345 break
5346 }
5347 v.reset(Op386MOVBstoreidx1)
5348 v.AuxInt = off
5349 v.Aux = sym
5350 v.AddArg(ptr)
5351 v.AddArg(idx)
5352 v.AddArg(val)
5353 v.AddArg(mem)
5354 return true
5355 }
5356
5357
5358
5359 for {
5360 i := v.AuxInt
5361 s := v.Aux
5362 _ = v.Args[2]
5363 p := v.Args[0]
5364 v_1 := v.Args[1]
5365 if v_1.Op != Op386SHRWconst {
5366 break
5367 }
5368 if v_1.AuxInt != 8 {
5369 break
5370 }
5371 w := v_1.Args[0]
5372 x := v.Args[2]
5373 if x.Op != Op386MOVBstore {
5374 break
5375 }
5376 if x.AuxInt != i-1 {
5377 break
5378 }
5379 if x.Aux != s {
5380 break
5381 }
5382 mem := x.Args[2]
5383 if p != x.Args[0] {
5384 break
5385 }
5386 if w != x.Args[1] {
5387 break
5388 }
5389 if !(x.Uses == 1 && clobber(x)) {
5390 break
5391 }
5392 v.reset(Op386MOVWstore)
5393 v.AuxInt = i - 1
5394 v.Aux = s
5395 v.AddArg(p)
5396 v.AddArg(w)
5397 v.AddArg(mem)
5398 return true
5399 }
5400
5401
5402
5403 for {
5404 i := v.AuxInt
5405 s := v.Aux
5406 _ = v.Args[2]
5407 p := v.Args[0]
5408 v_1 := v.Args[1]
5409 if v_1.Op != Op386SHRLconst {
5410 break
5411 }
5412 if v_1.AuxInt != 8 {
5413 break
5414 }
5415 w := v_1.Args[0]
5416 x := v.Args[2]
5417 if x.Op != Op386MOVBstore {
5418 break
5419 }
5420 if x.AuxInt != i-1 {
5421 break
5422 }
5423 if x.Aux != s {
5424 break
5425 }
5426 mem := x.Args[2]
5427 if p != x.Args[0] {
5428 break
5429 }
5430 if w != x.Args[1] {
5431 break
5432 }
5433 if !(x.Uses == 1 && clobber(x)) {
5434 break
5435 }
5436 v.reset(Op386MOVWstore)
5437 v.AuxInt = i - 1
5438 v.Aux = s
5439 v.AddArg(p)
5440 v.AddArg(w)
5441 v.AddArg(mem)
5442 return true
5443 }
5444
5445
5446
5447 for {
5448 i := v.AuxInt
5449 s := v.Aux
5450 _ = v.Args[2]
5451 p := v.Args[0]
5452 w := v.Args[1]
5453 x := v.Args[2]
5454 if x.Op != Op386MOVBstore {
5455 break
5456 }
5457 if x.AuxInt != i+1 {
5458 break
5459 }
5460 if x.Aux != s {
5461 break
5462 }
5463 mem := x.Args[2]
5464 if p != x.Args[0] {
5465 break
5466 }
5467 x_1 := x.Args[1]
5468 if x_1.Op != Op386SHRWconst {
5469 break
5470 }
5471 if x_1.AuxInt != 8 {
5472 break
5473 }
5474 if w != x_1.Args[0] {
5475 break
5476 }
5477 if !(x.Uses == 1 && clobber(x)) {
5478 break
5479 }
5480 v.reset(Op386MOVWstore)
5481 v.AuxInt = i
5482 v.Aux = s
5483 v.AddArg(p)
5484 v.AddArg(w)
5485 v.AddArg(mem)
5486 return true
5487 }
5488 return false
5489 }
5490 func rewriteValue386_Op386MOVBstore_10(v *Value) bool {
5491
5492
5493
5494 for {
5495 i := v.AuxInt
5496 s := v.Aux
5497 _ = v.Args[2]
5498 p := v.Args[0]
5499 w := v.Args[1]
5500 x := v.Args[2]
5501 if x.Op != Op386MOVBstore {
5502 break
5503 }
5504 if x.AuxInt != i+1 {
5505 break
5506 }
5507 if x.Aux != s {
5508 break
5509 }
5510 mem := x.Args[2]
5511 if p != x.Args[0] {
5512 break
5513 }
5514 x_1 := x.Args[1]
5515 if x_1.Op != Op386SHRLconst {
5516 break
5517 }
5518 if x_1.AuxInt != 8 {
5519 break
5520 }
5521 if w != x_1.Args[0] {
5522 break
5523 }
5524 if !(x.Uses == 1 && clobber(x)) {
5525 break
5526 }
5527 v.reset(Op386MOVWstore)
5528 v.AuxInt = i
5529 v.Aux = s
5530 v.AddArg(p)
5531 v.AddArg(w)
5532 v.AddArg(mem)
5533 return true
5534 }
5535
5536
5537
5538 for {
5539 i := v.AuxInt
5540 s := v.Aux
5541 _ = v.Args[2]
5542 p := v.Args[0]
5543 v_1 := v.Args[1]
5544 if v_1.Op != Op386SHRLconst {
5545 break
5546 }
5547 j := v_1.AuxInt
5548 w := v_1.Args[0]
5549 x := v.Args[2]
5550 if x.Op != Op386MOVBstore {
5551 break
5552 }
5553 if x.AuxInt != i-1 {
5554 break
5555 }
5556 if x.Aux != s {
5557 break
5558 }
5559 mem := x.Args[2]
5560 if p != x.Args[0] {
5561 break
5562 }
5563 w0 := x.Args[1]
5564 if w0.Op != Op386SHRLconst {
5565 break
5566 }
5567 if w0.AuxInt != j-8 {
5568 break
5569 }
5570 if w != w0.Args[0] {
5571 break
5572 }
5573 if !(x.Uses == 1 && clobber(x)) {
5574 break
5575 }
5576 v.reset(Op386MOVWstore)
5577 v.AuxInt = i - 1
5578 v.Aux = s
5579 v.AddArg(p)
5580 v.AddArg(w0)
5581 v.AddArg(mem)
5582 return true
5583 }
5584 return false
5585 }
5586 func rewriteValue386_Op386MOVBstoreconst_0(v *Value) bool {
5587 b := v.Block
5588 config := b.Func.Config
5589
5590
5591
5592 for {
5593 sc := v.AuxInt
5594 s := v.Aux
5595 mem := v.Args[1]
5596 v_0 := v.Args[0]
5597 if v_0.Op != Op386ADDLconst {
5598 break
5599 }
5600 off := v_0.AuxInt
5601 ptr := v_0.Args[0]
5602 if !(ValAndOff(sc).canAdd(off)) {
5603 break
5604 }
5605 v.reset(Op386MOVBstoreconst)
5606 v.AuxInt = ValAndOff(sc).add(off)
5607 v.Aux = s
5608 v.AddArg(ptr)
5609 v.AddArg(mem)
5610 return true
5611 }
5612
5613
5614
5615 for {
5616 sc := v.AuxInt
5617 sym1 := v.Aux
5618 mem := v.Args[1]
5619 v_0 := v.Args[0]
5620 if v_0.Op != Op386LEAL {
5621 break
5622 }
5623 off := v_0.AuxInt
5624 sym2 := v_0.Aux
5625 ptr := v_0.Args[0]
5626 if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)) {
5627 break
5628 }
5629 v.reset(Op386MOVBstoreconst)
5630 v.AuxInt = ValAndOff(sc).add(off)
5631 v.Aux = mergeSym(sym1, sym2)
5632 v.AddArg(ptr)
5633 v.AddArg(mem)
5634 return true
5635 }
5636
5637
5638
5639 for {
5640 x := v.AuxInt
5641 sym1 := v.Aux
5642 mem := v.Args[1]
5643 v_0 := v.Args[0]
5644 if v_0.Op != Op386LEAL1 {
5645 break
5646 }
5647 off := v_0.AuxInt
5648 sym2 := v_0.Aux
5649 idx := v_0.Args[1]
5650 ptr := v_0.Args[0]
5651 if !(canMergeSym(sym1, sym2)) {
5652 break
5653 }
5654 v.reset(Op386MOVBstoreconstidx1)
5655 v.AuxInt = ValAndOff(x).add(off)
5656 v.Aux = mergeSym(sym1, sym2)
5657 v.AddArg(ptr)
5658 v.AddArg(idx)
5659 v.AddArg(mem)
5660 return true
5661 }
5662
5663
5664
5665 for {
5666 x := v.AuxInt
5667 sym := v.Aux
5668 mem := v.Args[1]
5669 v_0 := v.Args[0]
5670 if v_0.Op != Op386ADDL {
5671 break
5672 }
5673 idx := v_0.Args[1]
5674 ptr := v_0.Args[0]
5675 v.reset(Op386MOVBstoreconstidx1)
5676 v.AuxInt = x
5677 v.Aux = sym
5678 v.AddArg(ptr)
5679 v.AddArg(idx)
5680 v.AddArg(mem)
5681 return true
5682 }
5683
5684
5685
5686 for {
5687 c := v.AuxInt
5688 s := v.Aux
5689 _ = v.Args[1]
5690 p := v.Args[0]
5691 x := v.Args[1]
5692 if x.Op != Op386MOVBstoreconst {
5693 break
5694 }
5695 a := x.AuxInt
5696 if x.Aux != s {
5697 break
5698 }
5699 mem := x.Args[1]
5700 if p != x.Args[0] {
5701 break
5702 }
5703 if !(x.Uses == 1 && ValAndOff(a).Off()+1 == ValAndOff(c).Off() && clobber(x)) {
5704 break
5705 }
5706 v.reset(Op386MOVWstoreconst)
5707 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xff|ValAndOff(c).Val()<<8, ValAndOff(a).Off())
5708 v.Aux = s
5709 v.AddArg(p)
5710 v.AddArg(mem)
5711 return true
5712 }
5713
5714
5715
5716 for {
5717 a := v.AuxInt
5718 s := v.Aux
5719 _ = v.Args[1]
5720 p := v.Args[0]
5721 x := v.Args[1]
5722 if x.Op != Op386MOVBstoreconst {
5723 break
5724 }
5725 c := x.AuxInt
5726 if x.Aux != s {
5727 break
5728 }
5729 mem := x.Args[1]
5730 if p != x.Args[0] {
5731 break
5732 }
5733 if !(x.Uses == 1 && ValAndOff(a).Off()+1 == ValAndOff(c).Off() && clobber(x)) {
5734 break
5735 }
5736 v.reset(Op386MOVWstoreconst)
5737 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xff|ValAndOff(c).Val()<<8, ValAndOff(a).Off())
5738 v.Aux = s
5739 v.AddArg(p)
5740 v.AddArg(mem)
5741 return true
5742 }
5743 return false
5744 }
5745 func rewriteValue386_Op386MOVBstoreconstidx1_0(v *Value) bool {
5746
5747
5748
5749 for {
5750 x := v.AuxInt
5751 sym := v.Aux
5752 mem := v.Args[2]
5753 v_0 := v.Args[0]
5754 if v_0.Op != Op386ADDLconst {
5755 break
5756 }
5757 c := v_0.AuxInt
5758 ptr := v_0.Args[0]
5759 idx := v.Args[1]
5760 v.reset(Op386MOVBstoreconstidx1)
5761 v.AuxInt = ValAndOff(x).add(c)
5762 v.Aux = sym
5763 v.AddArg(ptr)
5764 v.AddArg(idx)
5765 v.AddArg(mem)
5766 return true
5767 }
5768
5769
5770
5771 for {
5772 x := v.AuxInt
5773 sym := v.Aux
5774 mem := v.Args[2]
5775 ptr := v.Args[0]
5776 v_1 := v.Args[1]
5777 if v_1.Op != Op386ADDLconst {
5778 break
5779 }
5780 c := v_1.AuxInt
5781 idx := v_1.Args[0]
5782 v.reset(Op386MOVBstoreconstidx1)
5783 v.AuxInt = ValAndOff(x).add(c)
5784 v.Aux = sym
5785 v.AddArg(ptr)
5786 v.AddArg(idx)
5787 v.AddArg(mem)
5788 return true
5789 }
5790
5791
5792
5793 for {
5794 c := v.AuxInt
5795 s := v.Aux
5796 _ = v.Args[2]
5797 p := v.Args[0]
5798 i := v.Args[1]
5799 x := v.Args[2]
5800 if x.Op != Op386MOVBstoreconstidx1 {
5801 break
5802 }
5803 a := x.AuxInt
5804 if x.Aux != s {
5805 break
5806 }
5807 mem := x.Args[2]
5808 if p != x.Args[0] {
5809 break
5810 }
5811 if i != x.Args[1] {
5812 break
5813 }
5814 if !(x.Uses == 1 && ValAndOff(a).Off()+1 == ValAndOff(c).Off() && clobber(x)) {
5815 break
5816 }
5817 v.reset(Op386MOVWstoreconstidx1)
5818 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xff|ValAndOff(c).Val()<<8, ValAndOff(a).Off())
5819 v.Aux = s
5820 v.AddArg(p)
5821 v.AddArg(i)
5822 v.AddArg(mem)
5823 return true
5824 }
5825 return false
5826 }
5827 func rewriteValue386_Op386MOVBstoreidx1_0(v *Value) bool {
5828
5829
5830
5831 for {
5832 c := v.AuxInt
5833 sym := v.Aux
5834 mem := v.Args[3]
5835 v_0 := v.Args[0]
5836 if v_0.Op != Op386ADDLconst {
5837 break
5838 }
5839 d := v_0.AuxInt
5840 ptr := v_0.Args[0]
5841 idx := v.Args[1]
5842 val := v.Args[2]
5843 v.reset(Op386MOVBstoreidx1)
5844 v.AuxInt = int64(int32(c + d))
5845 v.Aux = sym
5846 v.AddArg(ptr)
5847 v.AddArg(idx)
5848 v.AddArg(val)
5849 v.AddArg(mem)
5850 return true
5851 }
5852
5853
5854
5855 for {
5856 c := v.AuxInt
5857 sym := v.Aux
5858 mem := v.Args[3]
5859 idx := v.Args[0]
5860 v_1 := v.Args[1]
5861 if v_1.Op != Op386ADDLconst {
5862 break
5863 }
5864 d := v_1.AuxInt
5865 ptr := v_1.Args[0]
5866 val := v.Args[2]
5867 v.reset(Op386MOVBstoreidx1)
5868 v.AuxInt = int64(int32(c + d))
5869 v.Aux = sym
5870 v.AddArg(ptr)
5871 v.AddArg(idx)
5872 v.AddArg(val)
5873 v.AddArg(mem)
5874 return true
5875 }
5876
5877
5878
5879 for {
5880 c := v.AuxInt
5881 sym := v.Aux
5882 mem := v.Args[3]
5883 ptr := v.Args[0]
5884 v_1 := v.Args[1]
5885 if v_1.Op != Op386ADDLconst {
5886 break
5887 }
5888 d := v_1.AuxInt
5889 idx := v_1.Args[0]
5890 val := v.Args[2]
5891 v.reset(Op386MOVBstoreidx1)
5892 v.AuxInt = int64(int32(c + d))
5893 v.Aux = sym
5894 v.AddArg(ptr)
5895 v.AddArg(idx)
5896 v.AddArg(val)
5897 v.AddArg(mem)
5898 return true
5899 }
5900
5901
5902
5903 for {
5904 c := v.AuxInt
5905 sym := v.Aux
5906 mem := v.Args[3]
5907 v_0 := v.Args[0]
5908 if v_0.Op != Op386ADDLconst {
5909 break
5910 }
5911 d := v_0.AuxInt
5912 idx := v_0.Args[0]
5913 ptr := v.Args[1]
5914 val := v.Args[2]
5915 v.reset(Op386MOVBstoreidx1)
5916 v.AuxInt = int64(int32(c + d))
5917 v.Aux = sym
5918 v.AddArg(ptr)
5919 v.AddArg(idx)
5920 v.AddArg(val)
5921 v.AddArg(mem)
5922 return true
5923 }
5924
5925
5926
5927 for {
5928 i := v.AuxInt
5929 s := v.Aux
5930 _ = v.Args[3]
5931 p := v.Args[0]
5932 idx := v.Args[1]
5933 v_2 := v.Args[2]
5934 if v_2.Op != Op386SHRLconst {
5935 break
5936 }
5937 if v_2.AuxInt != 8 {
5938 break
5939 }
5940 w := v_2.Args[0]
5941 x := v.Args[3]
5942 if x.Op != Op386MOVBstoreidx1 {
5943 break
5944 }
5945 if x.AuxInt != i-1 {
5946 break
5947 }
5948 if x.Aux != s {
5949 break
5950 }
5951 mem := x.Args[3]
5952 if p != x.Args[0] {
5953 break
5954 }
5955 if idx != x.Args[1] {
5956 break
5957 }
5958 if w != x.Args[2] {
5959 break
5960 }
5961 if !(x.Uses == 1 && clobber(x)) {
5962 break
5963 }
5964 v.reset(Op386MOVWstoreidx1)
5965 v.AuxInt = i - 1
5966 v.Aux = s
5967 v.AddArg(p)
5968 v.AddArg(idx)
5969 v.AddArg(w)
5970 v.AddArg(mem)
5971 return true
5972 }
5973
5974
5975
5976 for {
5977 i := v.AuxInt
5978 s := v.Aux
5979 _ = v.Args[3]
5980 p := v.Args[0]
5981 idx := v.Args[1]
5982 v_2 := v.Args[2]
5983 if v_2.Op != Op386SHRLconst {
5984 break
5985 }
5986 if v_2.AuxInt != 8 {
5987 break
5988 }
5989 w := v_2.Args[0]
5990 x := v.Args[3]
5991 if x.Op != Op386MOVBstoreidx1 {
5992 break
5993 }
5994 if x.AuxInt != i-1 {
5995 break
5996 }
5997 if x.Aux != s {
5998 break
5999 }
6000 mem := x.Args[3]
6001 if idx != x.Args[0] {
6002 break
6003 }
6004 if p != x.Args[1] {
6005 break
6006 }
6007 if w != x.Args[2] {
6008 break
6009 }
6010 if !(x.Uses == 1 && clobber(x)) {
6011 break
6012 }
6013 v.reset(Op386MOVWstoreidx1)
6014 v.AuxInt = i - 1
6015 v.Aux = s
6016 v.AddArg(p)
6017 v.AddArg(idx)
6018 v.AddArg(w)
6019 v.AddArg(mem)
6020 return true
6021 }
6022
6023
6024
6025 for {
6026 i := v.AuxInt
6027 s := v.Aux
6028 _ = v.Args[3]
6029 idx := v.Args[0]
6030 p := v.Args[1]
6031 v_2 := v.Args[2]
6032 if v_2.Op != Op386SHRLconst {
6033 break
6034 }
6035 if v_2.AuxInt != 8 {
6036 break
6037 }
6038 w := v_2.Args[0]
6039 x := v.Args[3]
6040 if x.Op != Op386MOVBstoreidx1 {
6041 break
6042 }
6043 if x.AuxInt != i-1 {
6044 break
6045 }
6046 if x.Aux != s {
6047 break
6048 }
6049 mem := x.Args[3]
6050 if p != x.Args[0] {
6051 break
6052 }
6053 if idx != x.Args[1] {
6054 break
6055 }
6056 if w != x.Args[2] {
6057 break
6058 }
6059 if !(x.Uses == 1 && clobber(x)) {
6060 break
6061 }
6062 v.reset(Op386MOVWstoreidx1)
6063 v.AuxInt = i - 1
6064 v.Aux = s
6065 v.AddArg(p)
6066 v.AddArg(idx)
6067 v.AddArg(w)
6068 v.AddArg(mem)
6069 return true
6070 }
6071
6072
6073
6074 for {
6075 i := v.AuxInt
6076 s := v.Aux
6077 _ = v.Args[3]
6078 idx := v.Args[0]
6079 p := v.Args[1]
6080 v_2 := v.Args[2]
6081 if v_2.Op != Op386SHRLconst {
6082 break
6083 }
6084 if v_2.AuxInt != 8 {
6085 break
6086 }
6087 w := v_2.Args[0]
6088 x := v.Args[3]
6089 if x.Op != Op386MOVBstoreidx1 {
6090 break
6091 }
6092 if x.AuxInt != i-1 {
6093 break
6094 }
6095 if x.Aux != s {
6096 break
6097 }
6098 mem := x.Args[3]
6099 if idx != x.Args[0] {
6100 break
6101 }
6102 if p != x.Args[1] {
6103 break
6104 }
6105 if w != x.Args[2] {
6106 break
6107 }
6108 if !(x.Uses == 1 && clobber(x)) {
6109 break
6110 }
6111 v.reset(Op386MOVWstoreidx1)
6112 v.AuxInt = i - 1
6113 v.Aux = s
6114 v.AddArg(p)
6115 v.AddArg(idx)
6116 v.AddArg(w)
6117 v.AddArg(mem)
6118 return true
6119 }
6120
6121
6122
6123 for {
6124 i := v.AuxInt
6125 s := v.Aux
6126 _ = v.Args[3]
6127 p := v.Args[0]
6128 idx := v.Args[1]
6129 v_2 := v.Args[2]
6130 if v_2.Op != Op386SHRWconst {
6131 break
6132 }
6133 if v_2.AuxInt != 8 {
6134 break
6135 }
6136 w := v_2.Args[0]
6137 x := v.Args[3]
6138 if x.Op != Op386MOVBstoreidx1 {
6139 break
6140 }
6141 if x.AuxInt != i-1 {
6142 break
6143 }
6144 if x.Aux != s {
6145 break
6146 }
6147 mem := x.Args[3]
6148 if p != x.Args[0] {
6149 break
6150 }
6151 if idx != x.Args[1] {
6152 break
6153 }
6154 if w != x.Args[2] {
6155 break
6156 }
6157 if !(x.Uses == 1 && clobber(x)) {
6158 break
6159 }
6160 v.reset(Op386MOVWstoreidx1)
6161 v.AuxInt = i - 1
6162 v.Aux = s
6163 v.AddArg(p)
6164 v.AddArg(idx)
6165 v.AddArg(w)
6166 v.AddArg(mem)
6167 return true
6168 }
6169
6170
6171
6172 for {
6173 i := v.AuxInt
6174 s := v.Aux
6175 _ = v.Args[3]
6176 p := v.Args[0]
6177 idx := v.Args[1]
6178 v_2 := v.Args[2]
6179 if v_2.Op != Op386SHRWconst {
6180 break
6181 }
6182 if v_2.AuxInt != 8 {
6183 break
6184 }
6185 w := v_2.Args[0]
6186 x := v.Args[3]
6187 if x.Op != Op386MOVBstoreidx1 {
6188 break
6189 }
6190 if x.AuxInt != i-1 {
6191 break
6192 }
6193 if x.Aux != s {
6194 break
6195 }
6196 mem := x.Args[3]
6197 if idx != x.Args[0] {
6198 break
6199 }
6200 if p != x.Args[1] {
6201 break
6202 }
6203 if w != x.Args[2] {
6204 break
6205 }
6206 if !(x.Uses == 1 && clobber(x)) {
6207 break
6208 }
6209 v.reset(Op386MOVWstoreidx1)
6210 v.AuxInt = i - 1
6211 v.Aux = s
6212 v.AddArg(p)
6213 v.AddArg(idx)
6214 v.AddArg(w)
6215 v.AddArg(mem)
6216 return true
6217 }
6218 return false
6219 }
6220 func rewriteValue386_Op386MOVBstoreidx1_10(v *Value) bool {
6221
6222
6223
6224 for {
6225 i := v.AuxInt
6226 s := v.Aux
6227 _ = v.Args[3]
6228 idx := v.Args[0]
6229 p := v.Args[1]
6230 v_2 := v.Args[2]
6231 if v_2.Op != Op386SHRWconst {
6232 break
6233 }
6234 if v_2.AuxInt != 8 {
6235 break
6236 }
6237 w := v_2.Args[0]
6238 x := v.Args[3]
6239 if x.Op != Op386MOVBstoreidx1 {
6240 break
6241 }
6242 if x.AuxInt != i-1 {
6243 break
6244 }
6245 if x.Aux != s {
6246 break
6247 }
6248 mem := x.Args[3]
6249 if p != x.Args[0] {
6250 break
6251 }
6252 if idx != x.Args[1] {
6253 break
6254 }
6255 if w != x.Args[2] {
6256 break
6257 }
6258 if !(x.Uses == 1 && clobber(x)) {
6259 break
6260 }
6261 v.reset(Op386MOVWstoreidx1)
6262 v.AuxInt = i - 1
6263 v.Aux = s
6264 v.AddArg(p)
6265 v.AddArg(idx)
6266 v.AddArg(w)
6267 v.AddArg(mem)
6268 return true
6269 }
6270
6271
6272
6273 for {
6274 i := v.AuxInt
6275 s := v.Aux
6276 _ = v.Args[3]
6277 idx := v.Args[0]
6278 p := v.Args[1]
6279 v_2 := v.Args[2]
6280 if v_2.Op != Op386SHRWconst {
6281 break
6282 }
6283 if v_2.AuxInt != 8 {
6284 break
6285 }
6286 w := v_2.Args[0]
6287 x := v.Args[3]
6288 if x.Op != Op386MOVBstoreidx1 {
6289 break
6290 }
6291 if x.AuxInt != i-1 {
6292 break
6293 }
6294 if x.Aux != s {
6295 break
6296 }
6297 mem := x.Args[3]
6298 if idx != x.Args[0] {
6299 break
6300 }
6301 if p != x.Args[1] {
6302 break
6303 }
6304 if w != x.Args[2] {
6305 break
6306 }
6307 if !(x.Uses == 1 && clobber(x)) {
6308 break
6309 }
6310 v.reset(Op386MOVWstoreidx1)
6311 v.AuxInt = i - 1
6312 v.Aux = s
6313 v.AddArg(p)
6314 v.AddArg(idx)
6315 v.AddArg(w)
6316 v.AddArg(mem)
6317 return true
6318 }
6319
6320
6321
6322 for {
6323 i := v.AuxInt
6324 s := v.Aux
6325 _ = v.Args[3]
6326 p := v.Args[0]
6327 idx := v.Args[1]
6328 w := v.Args[2]
6329 x := v.Args[3]
6330 if x.Op != Op386MOVBstoreidx1 {
6331 break
6332 }
6333 if x.AuxInt != i+1 {
6334 break
6335 }
6336 if x.Aux != s {
6337 break
6338 }
6339 mem := x.Args[3]
6340 if p != x.Args[0] {
6341 break
6342 }
6343 if idx != x.Args[1] {
6344 break
6345 }
6346 x_2 := x.Args[2]
6347 if x_2.Op != Op386SHRLconst {
6348 break
6349 }
6350 if x_2.AuxInt != 8 {
6351 break
6352 }
6353 if w != x_2.Args[0] {
6354 break
6355 }
6356 if !(x.Uses == 1 && clobber(x)) {
6357 break
6358 }
6359 v.reset(Op386MOVWstoreidx1)
6360 v.AuxInt = i
6361 v.Aux = s
6362 v.AddArg(p)
6363 v.AddArg(idx)
6364 v.AddArg(w)
6365 v.AddArg(mem)
6366 return true
6367 }
6368
6369
6370
6371 for {
6372 i := v.AuxInt
6373 s := v.Aux
6374 _ = v.Args[3]
6375 p := v.Args[0]
6376 idx := v.Args[1]
6377 w := v.Args[2]
6378 x := v.Args[3]
6379 if x.Op != Op386MOVBstoreidx1 {
6380 break
6381 }
6382 if x.AuxInt != i+1 {
6383 break
6384 }
6385 if x.Aux != s {
6386 break
6387 }
6388 mem := x.Args[3]
6389 if idx != x.Args[0] {
6390 break
6391 }
6392 if p != x.Args[1] {
6393 break
6394 }
6395 x_2 := x.Args[2]
6396 if x_2.Op != Op386SHRLconst {
6397 break
6398 }
6399 if x_2.AuxInt != 8 {
6400 break
6401 }
6402 if w != x_2.Args[0] {
6403 break
6404 }
6405 if !(x.Uses == 1 && clobber(x)) {
6406 break
6407 }
6408 v.reset(Op386MOVWstoreidx1)
6409 v.AuxInt = i
6410 v.Aux = s
6411 v.AddArg(p)
6412 v.AddArg(idx)
6413 v.AddArg(w)
6414 v.AddArg(mem)
6415 return true
6416 }
6417
6418
6419
6420 for {
6421 i := v.AuxInt
6422 s := v.Aux
6423 _ = v.Args[3]
6424 idx := v.Args[0]
6425 p := v.Args[1]
6426 w := v.Args[2]
6427 x := v.Args[3]
6428 if x.Op != Op386MOVBstoreidx1 {
6429 break
6430 }
6431 if x.AuxInt != i+1 {
6432 break
6433 }
6434 if x.Aux != s {
6435 break
6436 }
6437 mem := x.Args[3]
6438 if p != x.Args[0] {
6439 break
6440 }
6441 if idx != x.Args[1] {
6442 break
6443 }
6444 x_2 := x.Args[2]
6445 if x_2.Op != Op386SHRLconst {
6446 break
6447 }
6448 if x_2.AuxInt != 8 {
6449 break
6450 }
6451 if w != x_2.Args[0] {
6452 break
6453 }
6454 if !(x.Uses == 1 && clobber(x)) {
6455 break
6456 }
6457 v.reset(Op386MOVWstoreidx1)
6458 v.AuxInt = i
6459 v.Aux = s
6460 v.AddArg(p)
6461 v.AddArg(idx)
6462 v.AddArg(w)
6463 v.AddArg(mem)
6464 return true
6465 }
6466
6467
6468
6469 for {
6470 i := v.AuxInt
6471 s := v.Aux
6472 _ = v.Args[3]
6473 idx := v.Args[0]
6474 p := v.Args[1]
6475 w := v.Args[2]
6476 x := v.Args[3]
6477 if x.Op != Op386MOVBstoreidx1 {
6478 break
6479 }
6480 if x.AuxInt != i+1 {
6481 break
6482 }
6483 if x.Aux != s {
6484 break
6485 }
6486 mem := x.Args[3]
6487 if idx != x.Args[0] {
6488 break
6489 }
6490 if p != x.Args[1] {
6491 break
6492 }
6493 x_2 := x.Args[2]
6494 if x_2.Op != Op386SHRLconst {
6495 break
6496 }
6497 if x_2.AuxInt != 8 {
6498 break
6499 }
6500 if w != x_2.Args[0] {
6501 break
6502 }
6503 if !(x.Uses == 1 && clobber(x)) {
6504 break
6505 }
6506 v.reset(Op386MOVWstoreidx1)
6507 v.AuxInt = i
6508 v.Aux = s
6509 v.AddArg(p)
6510 v.AddArg(idx)
6511 v.AddArg(w)
6512 v.AddArg(mem)
6513 return true
6514 }
6515
6516
6517
6518 for {
6519 i := v.AuxInt
6520 s := v.Aux
6521 _ = v.Args[3]
6522 p := v.Args[0]
6523 idx := v.Args[1]
6524 w := v.Args[2]
6525 x := v.Args[3]
6526 if x.Op != Op386MOVBstoreidx1 {
6527 break
6528 }
6529 if x.AuxInt != i+1 {
6530 break
6531 }
6532 if x.Aux != s {
6533 break
6534 }
6535 mem := x.Args[3]
6536 if p != x.Args[0] {
6537 break
6538 }
6539 if idx != x.Args[1] {
6540 break
6541 }
6542 x_2 := x.Args[2]
6543 if x_2.Op != Op386SHRWconst {
6544 break
6545 }
6546 if x_2.AuxInt != 8 {
6547 break
6548 }
6549 if w != x_2.Args[0] {
6550 break
6551 }
6552 if !(x.Uses == 1 && clobber(x)) {
6553 break
6554 }
6555 v.reset(Op386MOVWstoreidx1)
6556 v.AuxInt = i
6557 v.Aux = s
6558 v.AddArg(p)
6559 v.AddArg(idx)
6560 v.AddArg(w)
6561 v.AddArg(mem)
6562 return true
6563 }
6564
6565
6566
6567 for {
6568 i := v.AuxInt
6569 s := v.Aux
6570 _ = v.Args[3]
6571 p := v.Args[0]
6572 idx := v.Args[1]
6573 w := v.Args[2]
6574 x := v.Args[3]
6575 if x.Op != Op386MOVBstoreidx1 {
6576 break
6577 }
6578 if x.AuxInt != i+1 {
6579 break
6580 }
6581 if x.Aux != s {
6582 break
6583 }
6584 mem := x.Args[3]
6585 if idx != x.Args[0] {
6586 break
6587 }
6588 if p != x.Args[1] {
6589 break
6590 }
6591 x_2 := x.Args[2]
6592 if x_2.Op != Op386SHRWconst {
6593 break
6594 }
6595 if x_2.AuxInt != 8 {
6596 break
6597 }
6598 if w != x_2.Args[0] {
6599 break
6600 }
6601 if !(x.Uses == 1 && clobber(x)) {
6602 break
6603 }
6604 v.reset(Op386MOVWstoreidx1)
6605 v.AuxInt = i
6606 v.Aux = s
6607 v.AddArg(p)
6608 v.AddArg(idx)
6609 v.AddArg(w)
6610 v.AddArg(mem)
6611 return true
6612 }
6613
6614
6615
6616 for {
6617 i := v.AuxInt
6618 s := v.Aux
6619 _ = v.Args[3]
6620 idx := v.Args[0]
6621 p := v.Args[1]
6622 w := v.Args[2]
6623 x := v.Args[3]
6624 if x.Op != Op386MOVBstoreidx1 {
6625 break
6626 }
6627 if x.AuxInt != i+1 {
6628 break
6629 }
6630 if x.Aux != s {
6631 break
6632 }
6633 mem := x.Args[3]
6634 if p != x.Args[0] {
6635 break
6636 }
6637 if idx != x.Args[1] {
6638 break
6639 }
6640 x_2 := x.Args[2]
6641 if x_2.Op != Op386SHRWconst {
6642 break
6643 }
6644 if x_2.AuxInt != 8 {
6645 break
6646 }
6647 if w != x_2.Args[0] {
6648 break
6649 }
6650 if !(x.Uses == 1 && clobber(x)) {
6651 break
6652 }
6653 v.reset(Op386MOVWstoreidx1)
6654 v.AuxInt = i
6655 v.Aux = s
6656 v.AddArg(p)
6657 v.AddArg(idx)
6658 v.AddArg(w)
6659 v.AddArg(mem)
6660 return true
6661 }
6662
6663
6664
6665 for {
6666 i := v.AuxInt
6667 s := v.Aux
6668 _ = v.Args[3]
6669 idx := v.Args[0]
6670 p := v.Args[1]
6671 w := v.Args[2]
6672 x := v.Args[3]
6673 if x.Op != Op386MOVBstoreidx1 {
6674 break
6675 }
6676 if x.AuxInt != i+1 {
6677 break
6678 }
6679 if x.Aux != s {
6680 break
6681 }
6682 mem := x.Args[3]
6683 if idx != x.Args[0] {
6684 break
6685 }
6686 if p != x.Args[1] {
6687 break
6688 }
6689 x_2 := x.Args[2]
6690 if x_2.Op != Op386SHRWconst {
6691 break
6692 }
6693 if x_2.AuxInt != 8 {
6694 break
6695 }
6696 if w != x_2.Args[0] {
6697 break
6698 }
6699 if !(x.Uses == 1 && clobber(x)) {
6700 break
6701 }
6702 v.reset(Op386MOVWstoreidx1)
6703 v.AuxInt = i
6704 v.Aux = s
6705 v.AddArg(p)
6706 v.AddArg(idx)
6707 v.AddArg(w)
6708 v.AddArg(mem)
6709 return true
6710 }
6711 return false
6712 }
6713 func rewriteValue386_Op386MOVBstoreidx1_20(v *Value) bool {
6714
6715
6716
6717 for {
6718 i := v.AuxInt
6719 s := v.Aux
6720 _ = v.Args[3]
6721 p := v.Args[0]
6722 idx := v.Args[1]
6723 v_2 := v.Args[2]
6724 if v_2.Op != Op386SHRLconst {
6725 break
6726 }
6727 j := v_2.AuxInt
6728 w := v_2.Args[0]
6729 x := v.Args[3]
6730 if x.Op != Op386MOVBstoreidx1 {
6731 break
6732 }
6733 if x.AuxInt != i-1 {
6734 break
6735 }
6736 if x.Aux != s {
6737 break
6738 }
6739 mem := x.Args[3]
6740 if p != x.Args[0] {
6741 break
6742 }
6743 if idx != x.Args[1] {
6744 break
6745 }
6746 w0 := x.Args[2]
6747 if w0.Op != Op386SHRLconst {
6748 break
6749 }
6750 if w0.AuxInt != j-8 {
6751 break
6752 }
6753 if w != w0.Args[0] {
6754 break
6755 }
6756 if !(x.Uses == 1 && clobber(x)) {
6757 break
6758 }
6759 v.reset(Op386MOVWstoreidx1)
6760 v.AuxInt = i - 1
6761 v.Aux = s
6762 v.AddArg(p)
6763 v.AddArg(idx)
6764 v.AddArg(w0)
6765 v.AddArg(mem)
6766 return true
6767 }
6768
6769
6770
6771 for {
6772 i := v.AuxInt
6773 s := v.Aux
6774 _ = v.Args[3]
6775 p := v.Args[0]
6776 idx := v.Args[1]
6777 v_2 := v.Args[2]
6778 if v_2.Op != Op386SHRLconst {
6779 break
6780 }
6781 j := v_2.AuxInt
6782 w := v_2.Args[0]
6783 x := v.Args[3]
6784 if x.Op != Op386MOVBstoreidx1 {
6785 break
6786 }
6787 if x.AuxInt != i-1 {
6788 break
6789 }
6790 if x.Aux != s {
6791 break
6792 }
6793 mem := x.Args[3]
6794 if idx != x.Args[0] {
6795 break
6796 }
6797 if p != x.Args[1] {
6798 break
6799 }
6800 w0 := x.Args[2]
6801 if w0.Op != Op386SHRLconst {
6802 break
6803 }
6804 if w0.AuxInt != j-8 {
6805 break
6806 }
6807 if w != w0.Args[0] {
6808 break
6809 }
6810 if !(x.Uses == 1 && clobber(x)) {
6811 break
6812 }
6813 v.reset(Op386MOVWstoreidx1)
6814 v.AuxInt = i - 1
6815 v.Aux = s
6816 v.AddArg(p)
6817 v.AddArg(idx)
6818 v.AddArg(w0)
6819 v.AddArg(mem)
6820 return true
6821 }
6822
6823
6824
6825 for {
6826 i := v.AuxInt
6827 s := v.Aux
6828 _ = v.Args[3]
6829 idx := v.Args[0]
6830 p := v.Args[1]
6831 v_2 := v.Args[2]
6832 if v_2.Op != Op386SHRLconst {
6833 break
6834 }
6835 j := v_2.AuxInt
6836 w := v_2.Args[0]
6837 x := v.Args[3]
6838 if x.Op != Op386MOVBstoreidx1 {
6839 break
6840 }
6841 if x.AuxInt != i-1 {
6842 break
6843 }
6844 if x.Aux != s {
6845 break
6846 }
6847 mem := x.Args[3]
6848 if p != x.Args[0] {
6849 break
6850 }
6851 if idx != x.Args[1] {
6852 break
6853 }
6854 w0 := x.Args[2]
6855 if w0.Op != Op386SHRLconst {
6856 break
6857 }
6858 if w0.AuxInt != j-8 {
6859 break
6860 }
6861 if w != w0.Args[0] {
6862 break
6863 }
6864 if !(x.Uses == 1 && clobber(x)) {
6865 break
6866 }
6867 v.reset(Op386MOVWstoreidx1)
6868 v.AuxInt = i - 1
6869 v.Aux = s
6870 v.AddArg(p)
6871 v.AddArg(idx)
6872 v.AddArg(w0)
6873 v.AddArg(mem)
6874 return true
6875 }
6876
6877
6878
6879 for {
6880 i := v.AuxInt
6881 s := v.Aux
6882 _ = v.Args[3]
6883 idx := v.Args[0]
6884 p := v.Args[1]
6885 v_2 := v.Args[2]
6886 if v_2.Op != Op386SHRLconst {
6887 break
6888 }
6889 j := v_2.AuxInt
6890 w := v_2.Args[0]
6891 x := v.Args[3]
6892 if x.Op != Op386MOVBstoreidx1 {
6893 break
6894 }
6895 if x.AuxInt != i-1 {
6896 break
6897 }
6898 if x.Aux != s {
6899 break
6900 }
6901 mem := x.Args[3]
6902 if idx != x.Args[0] {
6903 break
6904 }
6905 if p != x.Args[1] {
6906 break
6907 }
6908 w0 := x.Args[2]
6909 if w0.Op != Op386SHRLconst {
6910 break
6911 }
6912 if w0.AuxInt != j-8 {
6913 break
6914 }
6915 if w != w0.Args[0] {
6916 break
6917 }
6918 if !(x.Uses == 1 && clobber(x)) {
6919 break
6920 }
6921 v.reset(Op386MOVWstoreidx1)
6922 v.AuxInt = i - 1
6923 v.Aux = s
6924 v.AddArg(p)
6925 v.AddArg(idx)
6926 v.AddArg(w0)
6927 v.AddArg(mem)
6928 return true
6929 }
6930 return false
6931 }
6932 func rewriteValue386_Op386MOVLload_0(v *Value) bool {
6933 b := v.Block
6934 config := b.Func.Config
6935
6936
6937
6938 for {
6939 off := v.AuxInt
6940 sym := v.Aux
6941 _ = v.Args[1]
6942 ptr := v.Args[0]
6943 v_1 := v.Args[1]
6944 if v_1.Op != Op386MOVLstore {
6945 break
6946 }
6947 off2 := v_1.AuxInt
6948 sym2 := v_1.Aux
6949 _ = v_1.Args[2]
6950 ptr2 := v_1.Args[0]
6951 x := v_1.Args[1]
6952 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
6953 break
6954 }
6955 v.reset(OpCopy)
6956 v.Type = x.Type
6957 v.AddArg(x)
6958 return true
6959 }
6960
6961
6962
6963 for {
6964 off1 := v.AuxInt
6965 sym := v.Aux
6966 mem := v.Args[1]
6967 v_0 := v.Args[0]
6968 if v_0.Op != Op386ADDLconst {
6969 break
6970 }
6971 off2 := v_0.AuxInt
6972 ptr := v_0.Args[0]
6973 if !(is32Bit(off1 + off2)) {
6974 break
6975 }
6976 v.reset(Op386MOVLload)
6977 v.AuxInt = off1 + off2
6978 v.Aux = sym
6979 v.AddArg(ptr)
6980 v.AddArg(mem)
6981 return true
6982 }
6983
6984
6985
6986 for {
6987 off1 := v.AuxInt
6988 sym1 := v.Aux
6989 mem := v.Args[1]
6990 v_0 := v.Args[0]
6991 if v_0.Op != Op386LEAL {
6992 break
6993 }
6994 off2 := v_0.AuxInt
6995 sym2 := v_0.Aux
6996 base := v_0.Args[0]
6997 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
6998 break
6999 }
7000 v.reset(Op386MOVLload)
7001 v.AuxInt = off1 + off2
7002 v.Aux = mergeSym(sym1, sym2)
7003 v.AddArg(base)
7004 v.AddArg(mem)
7005 return true
7006 }
7007
7008
7009
7010 for {
7011 off1 := v.AuxInt
7012 sym1 := v.Aux
7013 mem := v.Args[1]
7014 v_0 := v.Args[0]
7015 if v_0.Op != Op386LEAL1 {
7016 break
7017 }
7018 off2 := v_0.AuxInt
7019 sym2 := v_0.Aux
7020 idx := v_0.Args[1]
7021 ptr := v_0.Args[0]
7022 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
7023 break
7024 }
7025 v.reset(Op386MOVLloadidx1)
7026 v.AuxInt = off1 + off2
7027 v.Aux = mergeSym(sym1, sym2)
7028 v.AddArg(ptr)
7029 v.AddArg(idx)
7030 v.AddArg(mem)
7031 return true
7032 }
7033
7034
7035
7036 for {
7037 off1 := v.AuxInt
7038 sym1 := v.Aux
7039 mem := v.Args[1]
7040 v_0 := v.Args[0]
7041 if v_0.Op != Op386LEAL4 {
7042 break
7043 }
7044 off2 := v_0.AuxInt
7045 sym2 := v_0.Aux
7046 idx := v_0.Args[1]
7047 ptr := v_0.Args[0]
7048 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
7049 break
7050 }
7051 v.reset(Op386MOVLloadidx4)
7052 v.AuxInt = off1 + off2
7053 v.Aux = mergeSym(sym1, sym2)
7054 v.AddArg(ptr)
7055 v.AddArg(idx)
7056 v.AddArg(mem)
7057 return true
7058 }
7059
7060
7061
7062 for {
7063 off := v.AuxInt
7064 sym := v.Aux
7065 mem := v.Args[1]
7066 v_0 := v.Args[0]
7067 if v_0.Op != Op386ADDL {
7068 break
7069 }
7070 idx := v_0.Args[1]
7071 ptr := v_0.Args[0]
7072 if !(ptr.Op != OpSB) {
7073 break
7074 }
7075 v.reset(Op386MOVLloadidx1)
7076 v.AuxInt = off
7077 v.Aux = sym
7078 v.AddArg(ptr)
7079 v.AddArg(idx)
7080 v.AddArg(mem)
7081 return true
7082 }
7083
7084
7085
7086 for {
7087 off := v.AuxInt
7088 sym := v.Aux
7089 _ = v.Args[1]
7090 v_0 := v.Args[0]
7091 if v_0.Op != OpSB {
7092 break
7093 }
7094 if !(symIsRO(sym)) {
7095 break
7096 }
7097 v.reset(Op386MOVLconst)
7098 v.AuxInt = int64(int32(read32(sym, off, config.BigEndian)))
7099 return true
7100 }
7101 return false
7102 }
7103 func rewriteValue386_Op386MOVLloadidx1_0(v *Value) bool {
7104
7105
7106
7107 for {
7108 c := v.AuxInt
7109 sym := v.Aux
7110 mem := v.Args[2]
7111 ptr := v.Args[0]
7112 v_1 := v.Args[1]
7113 if v_1.Op != Op386SHLLconst {
7114 break
7115 }
7116 if v_1.AuxInt != 2 {
7117 break
7118 }
7119 idx := v_1.Args[0]
7120 v.reset(Op386MOVLloadidx4)
7121 v.AuxInt = c
7122 v.Aux = sym
7123 v.AddArg(ptr)
7124 v.AddArg(idx)
7125 v.AddArg(mem)
7126 return true
7127 }
7128
7129
7130
7131 for {
7132 c := v.AuxInt
7133 sym := v.Aux
7134 mem := v.Args[2]
7135 v_0 := v.Args[0]
7136 if v_0.Op != Op386SHLLconst {
7137 break
7138 }
7139 if v_0.AuxInt != 2 {
7140 break
7141 }
7142 idx := v_0.Args[0]
7143 ptr := v.Args[1]
7144 v.reset(Op386MOVLloadidx4)
7145 v.AuxInt = c
7146 v.Aux = sym
7147 v.AddArg(ptr)
7148 v.AddArg(idx)
7149 v.AddArg(mem)
7150 return true
7151 }
7152
7153
7154
7155 for {
7156 c := v.AuxInt
7157 sym := v.Aux
7158 mem := v.Args[2]
7159 v_0 := v.Args[0]
7160 if v_0.Op != Op386ADDLconst {
7161 break
7162 }
7163 d := v_0.AuxInt
7164 ptr := v_0.Args[0]
7165 idx := v.Args[1]
7166 v.reset(Op386MOVLloadidx1)
7167 v.AuxInt = int64(int32(c + d))
7168 v.Aux = sym
7169 v.AddArg(ptr)
7170 v.AddArg(idx)
7171 v.AddArg(mem)
7172 return true
7173 }
7174
7175
7176
7177 for {
7178 c := v.AuxInt
7179 sym := v.Aux
7180 mem := v.Args[2]
7181 idx := v.Args[0]
7182 v_1 := v.Args[1]
7183 if v_1.Op != Op386ADDLconst {
7184 break
7185 }
7186 d := v_1.AuxInt
7187 ptr := v_1.Args[0]
7188 v.reset(Op386MOVLloadidx1)
7189 v.AuxInt = int64(int32(c + d))
7190 v.Aux = sym
7191 v.AddArg(ptr)
7192 v.AddArg(idx)
7193 v.AddArg(mem)
7194 return true
7195 }
7196
7197
7198
7199 for {
7200 c := v.AuxInt
7201 sym := v.Aux
7202 mem := v.Args[2]
7203 ptr := v.Args[0]
7204 v_1 := v.Args[1]
7205 if v_1.Op != Op386ADDLconst {
7206 break
7207 }
7208 d := v_1.AuxInt
7209 idx := v_1.Args[0]
7210 v.reset(Op386MOVLloadidx1)
7211 v.AuxInt = int64(int32(c + d))
7212 v.Aux = sym
7213 v.AddArg(ptr)
7214 v.AddArg(idx)
7215 v.AddArg(mem)
7216 return true
7217 }
7218
7219
7220
7221 for {
7222 c := v.AuxInt
7223 sym := v.Aux
7224 mem := v.Args[2]
7225 v_0 := v.Args[0]
7226 if v_0.Op != Op386ADDLconst {
7227 break
7228 }
7229 d := v_0.AuxInt
7230 idx := v_0.Args[0]
7231 ptr := v.Args[1]
7232 v.reset(Op386MOVLloadidx1)
7233 v.AuxInt = int64(int32(c + d))
7234 v.Aux = sym
7235 v.AddArg(ptr)
7236 v.AddArg(idx)
7237 v.AddArg(mem)
7238 return true
7239 }
7240 return false
7241 }
7242 func rewriteValue386_Op386MOVLloadidx4_0(v *Value) bool {
7243
7244
7245
7246 for {
7247 c := v.AuxInt
7248 sym := v.Aux
7249 mem := v.Args[2]
7250 v_0 := v.Args[0]
7251 if v_0.Op != Op386ADDLconst {
7252 break
7253 }
7254 d := v_0.AuxInt
7255 ptr := v_0.Args[0]
7256 idx := v.Args[1]
7257 v.reset(Op386MOVLloadidx4)
7258 v.AuxInt = int64(int32(c + d))
7259 v.Aux = sym
7260 v.AddArg(ptr)
7261 v.AddArg(idx)
7262 v.AddArg(mem)
7263 return true
7264 }
7265
7266
7267
7268 for {
7269 c := v.AuxInt
7270 sym := v.Aux
7271 mem := v.Args[2]
7272 ptr := v.Args[0]
7273 v_1 := v.Args[1]
7274 if v_1.Op != Op386ADDLconst {
7275 break
7276 }
7277 d := v_1.AuxInt
7278 idx := v_1.Args[0]
7279 v.reset(Op386MOVLloadidx4)
7280 v.AuxInt = int64(int32(c + 4*d))
7281 v.Aux = sym
7282 v.AddArg(ptr)
7283 v.AddArg(idx)
7284 v.AddArg(mem)
7285 return true
7286 }
7287 return false
7288 }
7289 func rewriteValue386_Op386MOVLstore_0(v *Value) bool {
7290 b := v.Block
7291 config := b.Func.Config
7292
7293
7294
7295 for {
7296 off1 := v.AuxInt
7297 sym := v.Aux
7298 mem := v.Args[2]
7299 v_0 := v.Args[0]
7300 if v_0.Op != Op386ADDLconst {
7301 break
7302 }
7303 off2 := v_0.AuxInt
7304 ptr := v_0.Args[0]
7305 val := v.Args[1]
7306 if !(is32Bit(off1 + off2)) {
7307 break
7308 }
7309 v.reset(Op386MOVLstore)
7310 v.AuxInt = off1 + off2
7311 v.Aux = sym
7312 v.AddArg(ptr)
7313 v.AddArg(val)
7314 v.AddArg(mem)
7315 return true
7316 }
7317
7318
7319
7320 for {
7321 off := v.AuxInt
7322 sym := v.Aux
7323 mem := v.Args[2]
7324 ptr := v.Args[0]
7325 v_1 := v.Args[1]
7326 if v_1.Op != Op386MOVLconst {
7327 break
7328 }
7329 c := v_1.AuxInt
7330 if !(validOff(off)) {
7331 break
7332 }
7333 v.reset(Op386MOVLstoreconst)
7334 v.AuxInt = makeValAndOff(int64(int32(c)), off)
7335 v.Aux = sym
7336 v.AddArg(ptr)
7337 v.AddArg(mem)
7338 return true
7339 }
7340
7341
7342
7343 for {
7344 off1 := v.AuxInt
7345 sym1 := v.Aux
7346 mem := v.Args[2]
7347 v_0 := v.Args[0]
7348 if v_0.Op != Op386LEAL {
7349 break
7350 }
7351 off2 := v_0.AuxInt
7352 sym2 := v_0.Aux
7353 base := v_0.Args[0]
7354 val := v.Args[1]
7355 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
7356 break
7357 }
7358 v.reset(Op386MOVLstore)
7359 v.AuxInt = off1 + off2
7360 v.Aux = mergeSym(sym1, sym2)
7361 v.AddArg(base)
7362 v.AddArg(val)
7363 v.AddArg(mem)
7364 return true
7365 }
7366
7367
7368
7369 for {
7370 off1 := v.AuxInt
7371 sym1 := v.Aux
7372 mem := v.Args[2]
7373 v_0 := v.Args[0]
7374 if v_0.Op != Op386LEAL1 {
7375 break
7376 }
7377 off2 := v_0.AuxInt
7378 sym2 := v_0.Aux
7379 idx := v_0.Args[1]
7380 ptr := v_0.Args[0]
7381 val := v.Args[1]
7382 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
7383 break
7384 }
7385 v.reset(Op386MOVLstoreidx1)
7386 v.AuxInt = off1 + off2
7387 v.Aux = mergeSym(sym1, sym2)
7388 v.AddArg(ptr)
7389 v.AddArg(idx)
7390 v.AddArg(val)
7391 v.AddArg(mem)
7392 return true
7393 }
7394
7395
7396
7397 for {
7398 off1 := v.AuxInt
7399 sym1 := v.Aux
7400 mem := v.Args[2]
7401 v_0 := v.Args[0]
7402 if v_0.Op != Op386LEAL4 {
7403 break
7404 }
7405 off2 := v_0.AuxInt
7406 sym2 := v_0.Aux
7407 idx := v_0.Args[1]
7408 ptr := v_0.Args[0]
7409 val := v.Args[1]
7410 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
7411 break
7412 }
7413 v.reset(Op386MOVLstoreidx4)
7414 v.AuxInt = off1 + off2
7415 v.Aux = mergeSym(sym1, sym2)
7416 v.AddArg(ptr)
7417 v.AddArg(idx)
7418 v.AddArg(val)
7419 v.AddArg(mem)
7420 return true
7421 }
7422
7423
7424
7425 for {
7426 off := v.AuxInt
7427 sym := v.Aux
7428 mem := v.Args[2]
7429 v_0 := v.Args[0]
7430 if v_0.Op != Op386ADDL {
7431 break
7432 }
7433 idx := v_0.Args[1]
7434 ptr := v_0.Args[0]
7435 val := v.Args[1]
7436 if !(ptr.Op != OpSB) {
7437 break
7438 }
7439 v.reset(Op386MOVLstoreidx1)
7440 v.AuxInt = off
7441 v.Aux = sym
7442 v.AddArg(ptr)
7443 v.AddArg(idx)
7444 v.AddArg(val)
7445 v.AddArg(mem)
7446 return true
7447 }
7448
7449
7450
7451 for {
7452 off := v.AuxInt
7453 sym := v.Aux
7454 mem := v.Args[2]
7455 ptr := v.Args[0]
7456 y := v.Args[1]
7457 if y.Op != Op386ADDLload {
7458 break
7459 }
7460 if y.AuxInt != off {
7461 break
7462 }
7463 if y.Aux != sym {
7464 break
7465 }
7466 _ = y.Args[2]
7467 x := y.Args[0]
7468 if ptr != y.Args[1] {
7469 break
7470 }
7471 if mem != y.Args[2] {
7472 break
7473 }
7474 if !(y.Uses == 1 && clobber(y)) {
7475 break
7476 }
7477 v.reset(Op386ADDLmodify)
7478 v.AuxInt = off
7479 v.Aux = sym
7480 v.AddArg(ptr)
7481 v.AddArg(x)
7482 v.AddArg(mem)
7483 return true
7484 }
7485
7486
7487
7488 for {
7489 off := v.AuxInt
7490 sym := v.Aux
7491 mem := v.Args[2]
7492 ptr := v.Args[0]
7493 y := v.Args[1]
7494 if y.Op != Op386ANDLload {
7495 break
7496 }
7497 if y.AuxInt != off {
7498 break
7499 }
7500 if y.Aux != sym {
7501 break
7502 }
7503 _ = y.Args[2]
7504 x := y.Args[0]
7505 if ptr != y.Args[1] {
7506 break
7507 }
7508 if mem != y.Args[2] {
7509 break
7510 }
7511 if !(y.Uses == 1 && clobber(y)) {
7512 break
7513 }
7514 v.reset(Op386ANDLmodify)
7515 v.AuxInt = off
7516 v.Aux = sym
7517 v.AddArg(ptr)
7518 v.AddArg(x)
7519 v.AddArg(mem)
7520 return true
7521 }
7522
7523
7524
7525 for {
7526 off := v.AuxInt
7527 sym := v.Aux
7528 mem := v.Args[2]
7529 ptr := v.Args[0]
7530 y := v.Args[1]
7531 if y.Op != Op386ORLload {
7532 break
7533 }
7534 if y.AuxInt != off {
7535 break
7536 }
7537 if y.Aux != sym {
7538 break
7539 }
7540 _ = y.Args[2]
7541 x := y.Args[0]
7542 if ptr != y.Args[1] {
7543 break
7544 }
7545 if mem != y.Args[2] {
7546 break
7547 }
7548 if !(y.Uses == 1 && clobber(y)) {
7549 break
7550 }
7551 v.reset(Op386ORLmodify)
7552 v.AuxInt = off
7553 v.Aux = sym
7554 v.AddArg(ptr)
7555 v.AddArg(x)
7556 v.AddArg(mem)
7557 return true
7558 }
7559
7560
7561
7562 for {
7563 off := v.AuxInt
7564 sym := v.Aux
7565 mem := v.Args[2]
7566 ptr := v.Args[0]
7567 y := v.Args[1]
7568 if y.Op != Op386XORLload {
7569 break
7570 }
7571 if y.AuxInt != off {
7572 break
7573 }
7574 if y.Aux != sym {
7575 break
7576 }
7577 _ = y.Args[2]
7578 x := y.Args[0]
7579 if ptr != y.Args[1] {
7580 break
7581 }
7582 if mem != y.Args[2] {
7583 break
7584 }
7585 if !(y.Uses == 1 && clobber(y)) {
7586 break
7587 }
7588 v.reset(Op386XORLmodify)
7589 v.AuxInt = off
7590 v.Aux = sym
7591 v.AddArg(ptr)
7592 v.AddArg(x)
7593 v.AddArg(mem)
7594 return true
7595 }
7596 return false
7597 }
7598 func rewriteValue386_Op386MOVLstore_10(v *Value) bool {
7599
7600
7601
7602 for {
7603 off := v.AuxInt
7604 sym := v.Aux
7605 mem := v.Args[2]
7606 ptr := v.Args[0]
7607 y := v.Args[1]
7608 if y.Op != Op386ADDL {
7609 break
7610 }
7611 x := y.Args[1]
7612 l := y.Args[0]
7613 if l.Op != Op386MOVLload {
7614 break
7615 }
7616 if l.AuxInt != off {
7617 break
7618 }
7619 if l.Aux != sym {
7620 break
7621 }
7622 _ = l.Args[1]
7623 if ptr != l.Args[0] {
7624 break
7625 }
7626 if mem != l.Args[1] {
7627 break
7628 }
7629 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
7630 break
7631 }
7632 v.reset(Op386ADDLmodify)
7633 v.AuxInt = off
7634 v.Aux = sym
7635 v.AddArg(ptr)
7636 v.AddArg(x)
7637 v.AddArg(mem)
7638 return true
7639 }
7640
7641
7642
7643 for {
7644 off := v.AuxInt
7645 sym := v.Aux
7646 mem := v.Args[2]
7647 ptr := v.Args[0]
7648 y := v.Args[1]
7649 if y.Op != Op386ADDL {
7650 break
7651 }
7652 _ = y.Args[1]
7653 x := y.Args[0]
7654 l := y.Args[1]
7655 if l.Op != Op386MOVLload {
7656 break
7657 }
7658 if l.AuxInt != off {
7659 break
7660 }
7661 if l.Aux != sym {
7662 break
7663 }
7664 _ = l.Args[1]
7665 if ptr != l.Args[0] {
7666 break
7667 }
7668 if mem != l.Args[1] {
7669 break
7670 }
7671 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
7672 break
7673 }
7674 v.reset(Op386ADDLmodify)
7675 v.AuxInt = off
7676 v.Aux = sym
7677 v.AddArg(ptr)
7678 v.AddArg(x)
7679 v.AddArg(mem)
7680 return true
7681 }
7682
7683
7684
7685 for {
7686 off := v.AuxInt
7687 sym := v.Aux
7688 mem := v.Args[2]
7689 ptr := v.Args[0]
7690 y := v.Args[1]
7691 if y.Op != Op386SUBL {
7692 break
7693 }
7694 x := y.Args[1]
7695 l := y.Args[0]
7696 if l.Op != Op386MOVLload {
7697 break
7698 }
7699 if l.AuxInt != off {
7700 break
7701 }
7702 if l.Aux != sym {
7703 break
7704 }
7705 _ = l.Args[1]
7706 if ptr != l.Args[0] {
7707 break
7708 }
7709 if mem != l.Args[1] {
7710 break
7711 }
7712 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
7713 break
7714 }
7715 v.reset(Op386SUBLmodify)
7716 v.AuxInt = off
7717 v.Aux = sym
7718 v.AddArg(ptr)
7719 v.AddArg(x)
7720 v.AddArg(mem)
7721 return true
7722 }
7723
7724
7725
7726 for {
7727 off := v.AuxInt
7728 sym := v.Aux
7729 mem := v.Args[2]
7730 ptr := v.Args[0]
7731 y := v.Args[1]
7732 if y.Op != Op386ANDL {
7733 break
7734 }
7735 x := y.Args[1]
7736 l := y.Args[0]
7737 if l.Op != Op386MOVLload {
7738 break
7739 }
7740 if l.AuxInt != off {
7741 break
7742 }
7743 if l.Aux != sym {
7744 break
7745 }
7746 _ = l.Args[1]
7747 if ptr != l.Args[0] {
7748 break
7749 }
7750 if mem != l.Args[1] {
7751 break
7752 }
7753 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
7754 break
7755 }
7756 v.reset(Op386ANDLmodify)
7757 v.AuxInt = off
7758 v.Aux = sym
7759 v.AddArg(ptr)
7760 v.AddArg(x)
7761 v.AddArg(mem)
7762 return true
7763 }
7764
7765
7766
7767 for {
7768 off := v.AuxInt
7769 sym := v.Aux
7770 mem := v.Args[2]
7771 ptr := v.Args[0]
7772 y := v.Args[1]
7773 if y.Op != Op386ANDL {
7774 break
7775 }
7776 _ = y.Args[1]
7777 x := y.Args[0]
7778 l := y.Args[1]
7779 if l.Op != Op386MOVLload {
7780 break
7781 }
7782 if l.AuxInt != off {
7783 break
7784 }
7785 if l.Aux != sym {
7786 break
7787 }
7788 _ = l.Args[1]
7789 if ptr != l.Args[0] {
7790 break
7791 }
7792 if mem != l.Args[1] {
7793 break
7794 }
7795 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
7796 break
7797 }
7798 v.reset(Op386ANDLmodify)
7799 v.AuxInt = off
7800 v.Aux = sym
7801 v.AddArg(ptr)
7802 v.AddArg(x)
7803 v.AddArg(mem)
7804 return true
7805 }
7806
7807
7808
7809 for {
7810 off := v.AuxInt
7811 sym := v.Aux
7812 mem := v.Args[2]
7813 ptr := v.Args[0]
7814 y := v.Args[1]
7815 if y.Op != Op386ORL {
7816 break
7817 }
7818 x := y.Args[1]
7819 l := y.Args[0]
7820 if l.Op != Op386MOVLload {
7821 break
7822 }
7823 if l.AuxInt != off {
7824 break
7825 }
7826 if l.Aux != sym {
7827 break
7828 }
7829 _ = l.Args[1]
7830 if ptr != l.Args[0] {
7831 break
7832 }
7833 if mem != l.Args[1] {
7834 break
7835 }
7836 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
7837 break
7838 }
7839 v.reset(Op386ORLmodify)
7840 v.AuxInt = off
7841 v.Aux = sym
7842 v.AddArg(ptr)
7843 v.AddArg(x)
7844 v.AddArg(mem)
7845 return true
7846 }
7847
7848
7849
7850 for {
7851 off := v.AuxInt
7852 sym := v.Aux
7853 mem := v.Args[2]
7854 ptr := v.Args[0]
7855 y := v.Args[1]
7856 if y.Op != Op386ORL {
7857 break
7858 }
7859 _ = y.Args[1]
7860 x := y.Args[0]
7861 l := y.Args[1]
7862 if l.Op != Op386MOVLload {
7863 break
7864 }
7865 if l.AuxInt != off {
7866 break
7867 }
7868 if l.Aux != sym {
7869 break
7870 }
7871 _ = l.Args[1]
7872 if ptr != l.Args[0] {
7873 break
7874 }
7875 if mem != l.Args[1] {
7876 break
7877 }
7878 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
7879 break
7880 }
7881 v.reset(Op386ORLmodify)
7882 v.AuxInt = off
7883 v.Aux = sym
7884 v.AddArg(ptr)
7885 v.AddArg(x)
7886 v.AddArg(mem)
7887 return true
7888 }
7889
7890
7891
7892 for {
7893 off := v.AuxInt
7894 sym := v.Aux
7895 mem := v.Args[2]
7896 ptr := v.Args[0]
7897 y := v.Args[1]
7898 if y.Op != Op386XORL {
7899 break
7900 }
7901 x := y.Args[1]
7902 l := y.Args[0]
7903 if l.Op != Op386MOVLload {
7904 break
7905 }
7906 if l.AuxInt != off {
7907 break
7908 }
7909 if l.Aux != sym {
7910 break
7911 }
7912 _ = l.Args[1]
7913 if ptr != l.Args[0] {
7914 break
7915 }
7916 if mem != l.Args[1] {
7917 break
7918 }
7919 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
7920 break
7921 }
7922 v.reset(Op386XORLmodify)
7923 v.AuxInt = off
7924 v.Aux = sym
7925 v.AddArg(ptr)
7926 v.AddArg(x)
7927 v.AddArg(mem)
7928 return true
7929 }
7930
7931
7932
7933 for {
7934 off := v.AuxInt
7935 sym := v.Aux
7936 mem := v.Args[2]
7937 ptr := v.Args[0]
7938 y := v.Args[1]
7939 if y.Op != Op386XORL {
7940 break
7941 }
7942 _ = y.Args[1]
7943 x := y.Args[0]
7944 l := y.Args[1]
7945 if l.Op != Op386MOVLload {
7946 break
7947 }
7948 if l.AuxInt != off {
7949 break
7950 }
7951 if l.Aux != sym {
7952 break
7953 }
7954 _ = l.Args[1]
7955 if ptr != l.Args[0] {
7956 break
7957 }
7958 if mem != l.Args[1] {
7959 break
7960 }
7961 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
7962 break
7963 }
7964 v.reset(Op386XORLmodify)
7965 v.AuxInt = off
7966 v.Aux = sym
7967 v.AddArg(ptr)
7968 v.AddArg(x)
7969 v.AddArg(mem)
7970 return true
7971 }
7972
7973
7974
7975 for {
7976 off := v.AuxInt
7977 sym := v.Aux
7978 mem := v.Args[2]
7979 ptr := v.Args[0]
7980 y := v.Args[1]
7981 if y.Op != Op386ADDLconst {
7982 break
7983 }
7984 c := y.AuxInt
7985 l := y.Args[0]
7986 if l.Op != Op386MOVLload {
7987 break
7988 }
7989 if l.AuxInt != off {
7990 break
7991 }
7992 if l.Aux != sym {
7993 break
7994 }
7995 _ = l.Args[1]
7996 if ptr != l.Args[0] {
7997 break
7998 }
7999 if mem != l.Args[1] {
8000 break
8001 }
8002 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) {
8003 break
8004 }
8005 v.reset(Op386ADDLconstmodify)
8006 v.AuxInt = makeValAndOff(c, off)
8007 v.Aux = sym
8008 v.AddArg(ptr)
8009 v.AddArg(mem)
8010 return true
8011 }
8012 return false
8013 }
8014 func rewriteValue386_Op386MOVLstore_20(v *Value) bool {
8015
8016
8017
8018 for {
8019 off := v.AuxInt
8020 sym := v.Aux
8021 mem := v.Args[2]
8022 ptr := v.Args[0]
8023 y := v.Args[1]
8024 if y.Op != Op386ANDLconst {
8025 break
8026 }
8027 c := y.AuxInt
8028 l := y.Args[0]
8029 if l.Op != Op386MOVLload {
8030 break
8031 }
8032 if l.AuxInt != off {
8033 break
8034 }
8035 if l.Aux != sym {
8036 break
8037 }
8038 _ = l.Args[1]
8039 if ptr != l.Args[0] {
8040 break
8041 }
8042 if mem != l.Args[1] {
8043 break
8044 }
8045 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) {
8046 break
8047 }
8048 v.reset(Op386ANDLconstmodify)
8049 v.AuxInt = makeValAndOff(c, off)
8050 v.Aux = sym
8051 v.AddArg(ptr)
8052 v.AddArg(mem)
8053 return true
8054 }
8055
8056
8057
8058 for {
8059 off := v.AuxInt
8060 sym := v.Aux
8061 mem := v.Args[2]
8062 ptr := v.Args[0]
8063 y := v.Args[1]
8064 if y.Op != Op386ORLconst {
8065 break
8066 }
8067 c := y.AuxInt
8068 l := y.Args[0]
8069 if l.Op != Op386MOVLload {
8070 break
8071 }
8072 if l.AuxInt != off {
8073 break
8074 }
8075 if l.Aux != sym {
8076 break
8077 }
8078 _ = l.Args[1]
8079 if ptr != l.Args[0] {
8080 break
8081 }
8082 if mem != l.Args[1] {
8083 break
8084 }
8085 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) {
8086 break
8087 }
8088 v.reset(Op386ORLconstmodify)
8089 v.AuxInt = makeValAndOff(c, off)
8090 v.Aux = sym
8091 v.AddArg(ptr)
8092 v.AddArg(mem)
8093 return true
8094 }
8095
8096
8097
8098 for {
8099 off := v.AuxInt
8100 sym := v.Aux
8101 mem := v.Args[2]
8102 ptr := v.Args[0]
8103 y := v.Args[1]
8104 if y.Op != Op386XORLconst {
8105 break
8106 }
8107 c := y.AuxInt
8108 l := y.Args[0]
8109 if l.Op != Op386MOVLload {
8110 break
8111 }
8112 if l.AuxInt != off {
8113 break
8114 }
8115 if l.Aux != sym {
8116 break
8117 }
8118 _ = l.Args[1]
8119 if ptr != l.Args[0] {
8120 break
8121 }
8122 if mem != l.Args[1] {
8123 break
8124 }
8125 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) {
8126 break
8127 }
8128 v.reset(Op386XORLconstmodify)
8129 v.AuxInt = makeValAndOff(c, off)
8130 v.Aux = sym
8131 v.AddArg(ptr)
8132 v.AddArg(mem)
8133 return true
8134 }
8135 return false
8136 }
8137 func rewriteValue386_Op386MOVLstoreconst_0(v *Value) bool {
8138 b := v.Block
8139 config := b.Func.Config
8140
8141
8142
8143 for {
8144 sc := v.AuxInt
8145 s := v.Aux
8146 mem := v.Args[1]
8147 v_0 := v.Args[0]
8148 if v_0.Op != Op386ADDLconst {
8149 break
8150 }
8151 off := v_0.AuxInt
8152 ptr := v_0.Args[0]
8153 if !(ValAndOff(sc).canAdd(off)) {
8154 break
8155 }
8156 v.reset(Op386MOVLstoreconst)
8157 v.AuxInt = ValAndOff(sc).add(off)
8158 v.Aux = s
8159 v.AddArg(ptr)
8160 v.AddArg(mem)
8161 return true
8162 }
8163
8164
8165
8166 for {
8167 sc := v.AuxInt
8168 sym1 := v.Aux
8169 mem := v.Args[1]
8170 v_0 := v.Args[0]
8171 if v_0.Op != Op386LEAL {
8172 break
8173 }
8174 off := v_0.AuxInt
8175 sym2 := v_0.Aux
8176 ptr := v_0.Args[0]
8177 if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)) {
8178 break
8179 }
8180 v.reset(Op386MOVLstoreconst)
8181 v.AuxInt = ValAndOff(sc).add(off)
8182 v.Aux = mergeSym(sym1, sym2)
8183 v.AddArg(ptr)
8184 v.AddArg(mem)
8185 return true
8186 }
8187
8188
8189
8190 for {
8191 x := v.AuxInt
8192 sym1 := v.Aux
8193 mem := v.Args[1]
8194 v_0 := v.Args[0]
8195 if v_0.Op != Op386LEAL1 {
8196 break
8197 }
8198 off := v_0.AuxInt
8199 sym2 := v_0.Aux
8200 idx := v_0.Args[1]
8201 ptr := v_0.Args[0]
8202 if !(canMergeSym(sym1, sym2)) {
8203 break
8204 }
8205 v.reset(Op386MOVLstoreconstidx1)
8206 v.AuxInt = ValAndOff(x).add(off)
8207 v.Aux = mergeSym(sym1, sym2)
8208 v.AddArg(ptr)
8209 v.AddArg(idx)
8210 v.AddArg(mem)
8211 return true
8212 }
8213
8214
8215
8216 for {
8217 x := v.AuxInt
8218 sym1 := v.Aux
8219 mem := v.Args[1]
8220 v_0 := v.Args[0]
8221 if v_0.Op != Op386LEAL4 {
8222 break
8223 }
8224 off := v_0.AuxInt
8225 sym2 := v_0.Aux
8226 idx := v_0.Args[1]
8227 ptr := v_0.Args[0]
8228 if !(canMergeSym(sym1, sym2)) {
8229 break
8230 }
8231 v.reset(Op386MOVLstoreconstidx4)
8232 v.AuxInt = ValAndOff(x).add(off)
8233 v.Aux = mergeSym(sym1, sym2)
8234 v.AddArg(ptr)
8235 v.AddArg(idx)
8236 v.AddArg(mem)
8237 return true
8238 }
8239
8240
8241
8242 for {
8243 x := v.AuxInt
8244 sym := v.Aux
8245 mem := v.Args[1]
8246 v_0 := v.Args[0]
8247 if v_0.Op != Op386ADDL {
8248 break
8249 }
8250 idx := v_0.Args[1]
8251 ptr := v_0.Args[0]
8252 v.reset(Op386MOVLstoreconstidx1)
8253 v.AuxInt = x
8254 v.Aux = sym
8255 v.AddArg(ptr)
8256 v.AddArg(idx)
8257 v.AddArg(mem)
8258 return true
8259 }
8260 return false
8261 }
8262 func rewriteValue386_Op386MOVLstoreconstidx1_0(v *Value) bool {
8263
8264
8265
8266 for {
8267 c := v.AuxInt
8268 sym := v.Aux
8269 mem := v.Args[2]
8270 ptr := v.Args[0]
8271 v_1 := v.Args[1]
8272 if v_1.Op != Op386SHLLconst {
8273 break
8274 }
8275 if v_1.AuxInt != 2 {
8276 break
8277 }
8278 idx := v_1.Args[0]
8279 v.reset(Op386MOVLstoreconstidx4)
8280 v.AuxInt = c
8281 v.Aux = sym
8282 v.AddArg(ptr)
8283 v.AddArg(idx)
8284 v.AddArg(mem)
8285 return true
8286 }
8287
8288
8289
8290 for {
8291 x := v.AuxInt
8292 sym := v.Aux
8293 mem := v.Args[2]
8294 v_0 := v.Args[0]
8295 if v_0.Op != Op386ADDLconst {
8296 break
8297 }
8298 c := v_0.AuxInt
8299 ptr := v_0.Args[0]
8300 idx := v.Args[1]
8301 v.reset(Op386MOVLstoreconstidx1)
8302 v.AuxInt = ValAndOff(x).add(c)
8303 v.Aux = sym
8304 v.AddArg(ptr)
8305 v.AddArg(idx)
8306 v.AddArg(mem)
8307 return true
8308 }
8309
8310
8311
8312 for {
8313 x := v.AuxInt
8314 sym := v.Aux
8315 mem := v.Args[2]
8316 ptr := v.Args[0]
8317 v_1 := v.Args[1]
8318 if v_1.Op != Op386ADDLconst {
8319 break
8320 }
8321 c := v_1.AuxInt
8322 idx := v_1.Args[0]
8323 v.reset(Op386MOVLstoreconstidx1)
8324 v.AuxInt = ValAndOff(x).add(c)
8325 v.Aux = sym
8326 v.AddArg(ptr)
8327 v.AddArg(idx)
8328 v.AddArg(mem)
8329 return true
8330 }
8331 return false
8332 }
8333 func rewriteValue386_Op386MOVLstoreconstidx4_0(v *Value) bool {
8334
8335
8336
8337 for {
8338 x := v.AuxInt
8339 sym := v.Aux
8340 mem := v.Args[2]
8341 v_0 := v.Args[0]
8342 if v_0.Op != Op386ADDLconst {
8343 break
8344 }
8345 c := v_0.AuxInt
8346 ptr := v_0.Args[0]
8347 idx := v.Args[1]
8348 v.reset(Op386MOVLstoreconstidx4)
8349 v.AuxInt = ValAndOff(x).add(c)
8350 v.Aux = sym
8351 v.AddArg(ptr)
8352 v.AddArg(idx)
8353 v.AddArg(mem)
8354 return true
8355 }
8356
8357
8358
8359 for {
8360 x := v.AuxInt
8361 sym := v.Aux
8362 mem := v.Args[2]
8363 ptr := v.Args[0]
8364 v_1 := v.Args[1]
8365 if v_1.Op != Op386ADDLconst {
8366 break
8367 }
8368 c := v_1.AuxInt
8369 idx := v_1.Args[0]
8370 v.reset(Op386MOVLstoreconstidx4)
8371 v.AuxInt = ValAndOff(x).add(4 * c)
8372 v.Aux = sym
8373 v.AddArg(ptr)
8374 v.AddArg(idx)
8375 v.AddArg(mem)
8376 return true
8377 }
8378 return false
8379 }
8380 func rewriteValue386_Op386MOVLstoreidx1_0(v *Value) bool {
8381
8382
8383
8384 for {
8385 c := v.AuxInt
8386 sym := v.Aux
8387 mem := v.Args[3]
8388 ptr := v.Args[0]
8389 v_1 := v.Args[1]
8390 if v_1.Op != Op386SHLLconst {
8391 break
8392 }
8393 if v_1.AuxInt != 2 {
8394 break
8395 }
8396 idx := v_1.Args[0]
8397 val := v.Args[2]
8398 v.reset(Op386MOVLstoreidx4)
8399 v.AuxInt = c
8400 v.Aux = sym
8401 v.AddArg(ptr)
8402 v.AddArg(idx)
8403 v.AddArg(val)
8404 v.AddArg(mem)
8405 return true
8406 }
8407
8408
8409
8410 for {
8411 c := v.AuxInt
8412 sym := v.Aux
8413 mem := v.Args[3]
8414 v_0 := v.Args[0]
8415 if v_0.Op != Op386SHLLconst {
8416 break
8417 }
8418 if v_0.AuxInt != 2 {
8419 break
8420 }
8421 idx := v_0.Args[0]
8422 ptr := v.Args[1]
8423 val := v.Args[2]
8424 v.reset(Op386MOVLstoreidx4)
8425 v.AuxInt = c
8426 v.Aux = sym
8427 v.AddArg(ptr)
8428 v.AddArg(idx)
8429 v.AddArg(val)
8430 v.AddArg(mem)
8431 return true
8432 }
8433
8434
8435
8436 for {
8437 c := v.AuxInt
8438 sym := v.Aux
8439 mem := v.Args[3]
8440 v_0 := v.Args[0]
8441 if v_0.Op != Op386ADDLconst {
8442 break
8443 }
8444 d := v_0.AuxInt
8445 ptr := v_0.Args[0]
8446 idx := v.Args[1]
8447 val := v.Args[2]
8448 v.reset(Op386MOVLstoreidx1)
8449 v.AuxInt = int64(int32(c + d))
8450 v.Aux = sym
8451 v.AddArg(ptr)
8452 v.AddArg(idx)
8453 v.AddArg(val)
8454 v.AddArg(mem)
8455 return true
8456 }
8457
8458
8459
8460 for {
8461 c := v.AuxInt
8462 sym := v.Aux
8463 mem := v.Args[3]
8464 idx := v.Args[0]
8465 v_1 := v.Args[1]
8466 if v_1.Op != Op386ADDLconst {
8467 break
8468 }
8469 d := v_1.AuxInt
8470 ptr := v_1.Args[0]
8471 val := v.Args[2]
8472 v.reset(Op386MOVLstoreidx1)
8473 v.AuxInt = int64(int32(c + d))
8474 v.Aux = sym
8475 v.AddArg(ptr)
8476 v.AddArg(idx)
8477 v.AddArg(val)
8478 v.AddArg(mem)
8479 return true
8480 }
8481
8482
8483
8484 for {
8485 c := v.AuxInt
8486 sym := v.Aux
8487 mem := v.Args[3]
8488 ptr := v.Args[0]
8489 v_1 := v.Args[1]
8490 if v_1.Op != Op386ADDLconst {
8491 break
8492 }
8493 d := v_1.AuxInt
8494 idx := v_1.Args[0]
8495 val := v.Args[2]
8496 v.reset(Op386MOVLstoreidx1)
8497 v.AuxInt = int64(int32(c + d))
8498 v.Aux = sym
8499 v.AddArg(ptr)
8500 v.AddArg(idx)
8501 v.AddArg(val)
8502 v.AddArg(mem)
8503 return true
8504 }
8505
8506
8507
8508 for {
8509 c := v.AuxInt
8510 sym := v.Aux
8511 mem := v.Args[3]
8512 v_0 := v.Args[0]
8513 if v_0.Op != Op386ADDLconst {
8514 break
8515 }
8516 d := v_0.AuxInt
8517 idx := v_0.Args[0]
8518 ptr := v.Args[1]
8519 val := v.Args[2]
8520 v.reset(Op386MOVLstoreidx1)
8521 v.AuxInt = int64(int32(c + d))
8522 v.Aux = sym
8523 v.AddArg(ptr)
8524 v.AddArg(idx)
8525 v.AddArg(val)
8526 v.AddArg(mem)
8527 return true
8528 }
8529 return false
8530 }
8531 func rewriteValue386_Op386MOVLstoreidx4_0(v *Value) bool {
8532
8533
8534
8535 for {
8536 c := v.AuxInt
8537 sym := v.Aux
8538 mem := v.Args[3]
8539 v_0 := v.Args[0]
8540 if v_0.Op != Op386ADDLconst {
8541 break
8542 }
8543 d := v_0.AuxInt
8544 ptr := v_0.Args[0]
8545 idx := v.Args[1]
8546 val := v.Args[2]
8547 v.reset(Op386MOVLstoreidx4)
8548 v.AuxInt = int64(int32(c + d))
8549 v.Aux = sym
8550 v.AddArg(ptr)
8551 v.AddArg(idx)
8552 v.AddArg(val)
8553 v.AddArg(mem)
8554 return true
8555 }
8556
8557
8558
8559 for {
8560 c := v.AuxInt
8561 sym := v.Aux
8562 mem := v.Args[3]
8563 ptr := v.Args[0]
8564 v_1 := v.Args[1]
8565 if v_1.Op != Op386ADDLconst {
8566 break
8567 }
8568 d := v_1.AuxInt
8569 idx := v_1.Args[0]
8570 val := v.Args[2]
8571 v.reset(Op386MOVLstoreidx4)
8572 v.AuxInt = int64(int32(c + 4*d))
8573 v.Aux = sym
8574 v.AddArg(ptr)
8575 v.AddArg(idx)
8576 v.AddArg(val)
8577 v.AddArg(mem)
8578 return true
8579 }
8580
8581
8582
8583 for {
8584 off := v.AuxInt
8585 sym := v.Aux
8586 mem := v.Args[3]
8587 ptr := v.Args[0]
8588 idx := v.Args[1]
8589 y := v.Args[2]
8590 if y.Op != Op386ADDLloadidx4 {
8591 break
8592 }
8593 if y.AuxInt != off {
8594 break
8595 }
8596 if y.Aux != sym {
8597 break
8598 }
8599 _ = y.Args[3]
8600 x := y.Args[0]
8601 if ptr != y.Args[1] {
8602 break
8603 }
8604 if idx != y.Args[2] {
8605 break
8606 }
8607 if mem != y.Args[3] {
8608 break
8609 }
8610 if !(y.Uses == 1 && clobber(y)) {
8611 break
8612 }
8613 v.reset(Op386ADDLmodifyidx4)
8614 v.AuxInt = off
8615 v.Aux = sym
8616 v.AddArg(ptr)
8617 v.AddArg(idx)
8618 v.AddArg(x)
8619 v.AddArg(mem)
8620 return true
8621 }
8622
8623
8624
8625 for {
8626 off := v.AuxInt
8627 sym := v.Aux
8628 mem := v.Args[3]
8629 ptr := v.Args[0]
8630 idx := v.Args[1]
8631 y := v.Args[2]
8632 if y.Op != Op386ANDLloadidx4 {
8633 break
8634 }
8635 if y.AuxInt != off {
8636 break
8637 }
8638 if y.Aux != sym {
8639 break
8640 }
8641 _ = y.Args[3]
8642 x := y.Args[0]
8643 if ptr != y.Args[1] {
8644 break
8645 }
8646 if idx != y.Args[2] {
8647 break
8648 }
8649 if mem != y.Args[3] {
8650 break
8651 }
8652 if !(y.Uses == 1 && clobber(y)) {
8653 break
8654 }
8655 v.reset(Op386ANDLmodifyidx4)
8656 v.AuxInt = off
8657 v.Aux = sym
8658 v.AddArg(ptr)
8659 v.AddArg(idx)
8660 v.AddArg(x)
8661 v.AddArg(mem)
8662 return true
8663 }
8664
8665
8666
8667 for {
8668 off := v.AuxInt
8669 sym := v.Aux
8670 mem := v.Args[3]
8671 ptr := v.Args[0]
8672 idx := v.Args[1]
8673 y := v.Args[2]
8674 if y.Op != Op386ORLloadidx4 {
8675 break
8676 }
8677 if y.AuxInt != off {
8678 break
8679 }
8680 if y.Aux != sym {
8681 break
8682 }
8683 _ = y.Args[3]
8684 x := y.Args[0]
8685 if ptr != y.Args[1] {
8686 break
8687 }
8688 if idx != y.Args[2] {
8689 break
8690 }
8691 if mem != y.Args[3] {
8692 break
8693 }
8694 if !(y.Uses == 1 && clobber(y)) {
8695 break
8696 }
8697 v.reset(Op386ORLmodifyidx4)
8698 v.AuxInt = off
8699 v.Aux = sym
8700 v.AddArg(ptr)
8701 v.AddArg(idx)
8702 v.AddArg(x)
8703 v.AddArg(mem)
8704 return true
8705 }
8706
8707
8708
8709 for {
8710 off := v.AuxInt
8711 sym := v.Aux
8712 mem := v.Args[3]
8713 ptr := v.Args[0]
8714 idx := v.Args[1]
8715 y := v.Args[2]
8716 if y.Op != Op386XORLloadidx4 {
8717 break
8718 }
8719 if y.AuxInt != off {
8720 break
8721 }
8722 if y.Aux != sym {
8723 break
8724 }
8725 _ = y.Args[3]
8726 x := y.Args[0]
8727 if ptr != y.Args[1] {
8728 break
8729 }
8730 if idx != y.Args[2] {
8731 break
8732 }
8733 if mem != y.Args[3] {
8734 break
8735 }
8736 if !(y.Uses == 1 && clobber(y)) {
8737 break
8738 }
8739 v.reset(Op386XORLmodifyidx4)
8740 v.AuxInt = off
8741 v.Aux = sym
8742 v.AddArg(ptr)
8743 v.AddArg(idx)
8744 v.AddArg(x)
8745 v.AddArg(mem)
8746 return true
8747 }
8748
8749
8750
8751 for {
8752 off := v.AuxInt
8753 sym := v.Aux
8754 mem := v.Args[3]
8755 ptr := v.Args[0]
8756 idx := v.Args[1]
8757 y := v.Args[2]
8758 if y.Op != Op386ADDL {
8759 break
8760 }
8761 x := y.Args[1]
8762 l := y.Args[0]
8763 if l.Op != Op386MOVLloadidx4 {
8764 break
8765 }
8766 if l.AuxInt != off {
8767 break
8768 }
8769 if l.Aux != sym {
8770 break
8771 }
8772 _ = l.Args[2]
8773 if ptr != l.Args[0] {
8774 break
8775 }
8776 if idx != l.Args[1] {
8777 break
8778 }
8779 if mem != l.Args[2] {
8780 break
8781 }
8782 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
8783 break
8784 }
8785 v.reset(Op386ADDLmodifyidx4)
8786 v.AuxInt = off
8787 v.Aux = sym
8788 v.AddArg(ptr)
8789 v.AddArg(idx)
8790 v.AddArg(x)
8791 v.AddArg(mem)
8792 return true
8793 }
8794
8795
8796
8797 for {
8798 off := v.AuxInt
8799 sym := v.Aux
8800 mem := v.Args[3]
8801 ptr := v.Args[0]
8802 idx := v.Args[1]
8803 y := v.Args[2]
8804 if y.Op != Op386ADDL {
8805 break
8806 }
8807 _ = y.Args[1]
8808 x := y.Args[0]
8809 l := y.Args[1]
8810 if l.Op != Op386MOVLloadidx4 {
8811 break
8812 }
8813 if l.AuxInt != off {
8814 break
8815 }
8816 if l.Aux != sym {
8817 break
8818 }
8819 _ = l.Args[2]
8820 if ptr != l.Args[0] {
8821 break
8822 }
8823 if idx != l.Args[1] {
8824 break
8825 }
8826 if mem != l.Args[2] {
8827 break
8828 }
8829 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
8830 break
8831 }
8832 v.reset(Op386ADDLmodifyidx4)
8833 v.AuxInt = off
8834 v.Aux = sym
8835 v.AddArg(ptr)
8836 v.AddArg(idx)
8837 v.AddArg(x)
8838 v.AddArg(mem)
8839 return true
8840 }
8841
8842
8843
8844 for {
8845 off := v.AuxInt
8846 sym := v.Aux
8847 mem := v.Args[3]
8848 ptr := v.Args[0]
8849 idx := v.Args[1]
8850 y := v.Args[2]
8851 if y.Op != Op386SUBL {
8852 break
8853 }
8854 x := y.Args[1]
8855 l := y.Args[0]
8856 if l.Op != Op386MOVLloadidx4 {
8857 break
8858 }
8859 if l.AuxInt != off {
8860 break
8861 }
8862 if l.Aux != sym {
8863 break
8864 }
8865 _ = l.Args[2]
8866 if ptr != l.Args[0] {
8867 break
8868 }
8869 if idx != l.Args[1] {
8870 break
8871 }
8872 if mem != l.Args[2] {
8873 break
8874 }
8875 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
8876 break
8877 }
8878 v.reset(Op386SUBLmodifyidx4)
8879 v.AuxInt = off
8880 v.Aux = sym
8881 v.AddArg(ptr)
8882 v.AddArg(idx)
8883 v.AddArg(x)
8884 v.AddArg(mem)
8885 return true
8886 }
8887
8888
8889
8890 for {
8891 off := v.AuxInt
8892 sym := v.Aux
8893 mem := v.Args[3]
8894 ptr := v.Args[0]
8895 idx := v.Args[1]
8896 y := v.Args[2]
8897 if y.Op != Op386ANDL {
8898 break
8899 }
8900 x := y.Args[1]
8901 l := y.Args[0]
8902 if l.Op != Op386MOVLloadidx4 {
8903 break
8904 }
8905 if l.AuxInt != off {
8906 break
8907 }
8908 if l.Aux != sym {
8909 break
8910 }
8911 _ = l.Args[2]
8912 if ptr != l.Args[0] {
8913 break
8914 }
8915 if idx != l.Args[1] {
8916 break
8917 }
8918 if mem != l.Args[2] {
8919 break
8920 }
8921 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
8922 break
8923 }
8924 v.reset(Op386ANDLmodifyidx4)
8925 v.AuxInt = off
8926 v.Aux = sym
8927 v.AddArg(ptr)
8928 v.AddArg(idx)
8929 v.AddArg(x)
8930 v.AddArg(mem)
8931 return true
8932 }
8933 return false
8934 }
8935 func rewriteValue386_Op386MOVLstoreidx4_10(v *Value) bool {
8936
8937
8938
8939 for {
8940 off := v.AuxInt
8941 sym := v.Aux
8942 mem := v.Args[3]
8943 ptr := v.Args[0]
8944 idx := v.Args[1]
8945 y := v.Args[2]
8946 if y.Op != Op386ANDL {
8947 break
8948 }
8949 _ = y.Args[1]
8950 x := y.Args[0]
8951 l := y.Args[1]
8952 if l.Op != Op386MOVLloadidx4 {
8953 break
8954 }
8955 if l.AuxInt != off {
8956 break
8957 }
8958 if l.Aux != sym {
8959 break
8960 }
8961 _ = l.Args[2]
8962 if ptr != l.Args[0] {
8963 break
8964 }
8965 if idx != l.Args[1] {
8966 break
8967 }
8968 if mem != l.Args[2] {
8969 break
8970 }
8971 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
8972 break
8973 }
8974 v.reset(Op386ANDLmodifyidx4)
8975 v.AuxInt = off
8976 v.Aux = sym
8977 v.AddArg(ptr)
8978 v.AddArg(idx)
8979 v.AddArg(x)
8980 v.AddArg(mem)
8981 return true
8982 }
8983
8984
8985
8986 for {
8987 off := v.AuxInt
8988 sym := v.Aux
8989 mem := v.Args[3]
8990 ptr := v.Args[0]
8991 idx := v.Args[1]
8992 y := v.Args[2]
8993 if y.Op != Op386ORL {
8994 break
8995 }
8996 x := y.Args[1]
8997 l := y.Args[0]
8998 if l.Op != Op386MOVLloadidx4 {
8999 break
9000 }
9001 if l.AuxInt != off {
9002 break
9003 }
9004 if l.Aux != sym {
9005 break
9006 }
9007 _ = l.Args[2]
9008 if ptr != l.Args[0] {
9009 break
9010 }
9011 if idx != l.Args[1] {
9012 break
9013 }
9014 if mem != l.Args[2] {
9015 break
9016 }
9017 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
9018 break
9019 }
9020 v.reset(Op386ORLmodifyidx4)
9021 v.AuxInt = off
9022 v.Aux = sym
9023 v.AddArg(ptr)
9024 v.AddArg(idx)
9025 v.AddArg(x)
9026 v.AddArg(mem)
9027 return true
9028 }
9029
9030
9031
9032 for {
9033 off := v.AuxInt
9034 sym := v.Aux
9035 mem := v.Args[3]
9036 ptr := v.Args[0]
9037 idx := v.Args[1]
9038 y := v.Args[2]
9039 if y.Op != Op386ORL {
9040 break
9041 }
9042 _ = y.Args[1]
9043 x := y.Args[0]
9044 l := y.Args[1]
9045 if l.Op != Op386MOVLloadidx4 {
9046 break
9047 }
9048 if l.AuxInt != off {
9049 break
9050 }
9051 if l.Aux != sym {
9052 break
9053 }
9054 _ = l.Args[2]
9055 if ptr != l.Args[0] {
9056 break
9057 }
9058 if idx != l.Args[1] {
9059 break
9060 }
9061 if mem != l.Args[2] {
9062 break
9063 }
9064 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
9065 break
9066 }
9067 v.reset(Op386ORLmodifyidx4)
9068 v.AuxInt = off
9069 v.Aux = sym
9070 v.AddArg(ptr)
9071 v.AddArg(idx)
9072 v.AddArg(x)
9073 v.AddArg(mem)
9074 return true
9075 }
9076
9077
9078
9079 for {
9080 off := v.AuxInt
9081 sym := v.Aux
9082 mem := v.Args[3]
9083 ptr := v.Args[0]
9084 idx := v.Args[1]
9085 y := v.Args[2]
9086 if y.Op != Op386XORL {
9087 break
9088 }
9089 x := y.Args[1]
9090 l := y.Args[0]
9091 if l.Op != Op386MOVLloadidx4 {
9092 break
9093 }
9094 if l.AuxInt != off {
9095 break
9096 }
9097 if l.Aux != sym {
9098 break
9099 }
9100 _ = l.Args[2]
9101 if ptr != l.Args[0] {
9102 break
9103 }
9104 if idx != l.Args[1] {
9105 break
9106 }
9107 if mem != l.Args[2] {
9108 break
9109 }
9110 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
9111 break
9112 }
9113 v.reset(Op386XORLmodifyidx4)
9114 v.AuxInt = off
9115 v.Aux = sym
9116 v.AddArg(ptr)
9117 v.AddArg(idx)
9118 v.AddArg(x)
9119 v.AddArg(mem)
9120 return true
9121 }
9122
9123
9124
9125 for {
9126 off := v.AuxInt
9127 sym := v.Aux
9128 mem := v.Args[3]
9129 ptr := v.Args[0]
9130 idx := v.Args[1]
9131 y := v.Args[2]
9132 if y.Op != Op386XORL {
9133 break
9134 }
9135 _ = y.Args[1]
9136 x := y.Args[0]
9137 l := y.Args[1]
9138 if l.Op != Op386MOVLloadidx4 {
9139 break
9140 }
9141 if l.AuxInt != off {
9142 break
9143 }
9144 if l.Aux != sym {
9145 break
9146 }
9147 _ = l.Args[2]
9148 if ptr != l.Args[0] {
9149 break
9150 }
9151 if idx != l.Args[1] {
9152 break
9153 }
9154 if mem != l.Args[2] {
9155 break
9156 }
9157 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l)) {
9158 break
9159 }
9160 v.reset(Op386XORLmodifyidx4)
9161 v.AuxInt = off
9162 v.Aux = sym
9163 v.AddArg(ptr)
9164 v.AddArg(idx)
9165 v.AddArg(x)
9166 v.AddArg(mem)
9167 return true
9168 }
9169
9170
9171
9172 for {
9173 off := v.AuxInt
9174 sym := v.Aux
9175 mem := v.Args[3]
9176 ptr := v.Args[0]
9177 idx := v.Args[1]
9178 y := v.Args[2]
9179 if y.Op != Op386ADDLconst {
9180 break
9181 }
9182 c := y.AuxInt
9183 l := y.Args[0]
9184 if l.Op != Op386MOVLloadidx4 {
9185 break
9186 }
9187 if l.AuxInt != off {
9188 break
9189 }
9190 if l.Aux != sym {
9191 break
9192 }
9193 _ = l.Args[2]
9194 if ptr != l.Args[0] {
9195 break
9196 }
9197 if idx != l.Args[1] {
9198 break
9199 }
9200 if mem != l.Args[2] {
9201 break
9202 }
9203 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) {
9204 break
9205 }
9206 v.reset(Op386ADDLconstmodifyidx4)
9207 v.AuxInt = makeValAndOff(c, off)
9208 v.Aux = sym
9209 v.AddArg(ptr)
9210 v.AddArg(idx)
9211 v.AddArg(mem)
9212 return true
9213 }
9214
9215
9216
9217 for {
9218 off := v.AuxInt
9219 sym := v.Aux
9220 mem := v.Args[3]
9221 ptr := v.Args[0]
9222 idx := v.Args[1]
9223 y := v.Args[2]
9224 if y.Op != Op386ANDLconst {
9225 break
9226 }
9227 c := y.AuxInt
9228 l := y.Args[0]
9229 if l.Op != Op386MOVLloadidx4 {
9230 break
9231 }
9232 if l.AuxInt != off {
9233 break
9234 }
9235 if l.Aux != sym {
9236 break
9237 }
9238 _ = l.Args[2]
9239 if ptr != l.Args[0] {
9240 break
9241 }
9242 if idx != l.Args[1] {
9243 break
9244 }
9245 if mem != l.Args[2] {
9246 break
9247 }
9248 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) {
9249 break
9250 }
9251 v.reset(Op386ANDLconstmodifyidx4)
9252 v.AuxInt = makeValAndOff(c, off)
9253 v.Aux = sym
9254 v.AddArg(ptr)
9255 v.AddArg(idx)
9256 v.AddArg(mem)
9257 return true
9258 }
9259
9260
9261
9262 for {
9263 off := v.AuxInt
9264 sym := v.Aux
9265 mem := v.Args[3]
9266 ptr := v.Args[0]
9267 idx := v.Args[1]
9268 y := v.Args[2]
9269 if y.Op != Op386ORLconst {
9270 break
9271 }
9272 c := y.AuxInt
9273 l := y.Args[0]
9274 if l.Op != Op386MOVLloadidx4 {
9275 break
9276 }
9277 if l.AuxInt != off {
9278 break
9279 }
9280 if l.Aux != sym {
9281 break
9282 }
9283 _ = l.Args[2]
9284 if ptr != l.Args[0] {
9285 break
9286 }
9287 if idx != l.Args[1] {
9288 break
9289 }
9290 if mem != l.Args[2] {
9291 break
9292 }
9293 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) {
9294 break
9295 }
9296 v.reset(Op386ORLconstmodifyidx4)
9297 v.AuxInt = makeValAndOff(c, off)
9298 v.Aux = sym
9299 v.AddArg(ptr)
9300 v.AddArg(idx)
9301 v.AddArg(mem)
9302 return true
9303 }
9304
9305
9306
9307 for {
9308 off := v.AuxInt
9309 sym := v.Aux
9310 mem := v.Args[3]
9311 ptr := v.Args[0]
9312 idx := v.Args[1]
9313 y := v.Args[2]
9314 if y.Op != Op386XORLconst {
9315 break
9316 }
9317 c := y.AuxInt
9318 l := y.Args[0]
9319 if l.Op != Op386MOVLloadidx4 {
9320 break
9321 }
9322 if l.AuxInt != off {
9323 break
9324 }
9325 if l.Aux != sym {
9326 break
9327 }
9328 _ = l.Args[2]
9329 if ptr != l.Args[0] {
9330 break
9331 }
9332 if idx != l.Args[1] {
9333 break
9334 }
9335 if mem != l.Args[2] {
9336 break
9337 }
9338 if !(y.Uses == 1 && l.Uses == 1 && clobber(y) && clobber(l) && validValAndOff(c, off)) {
9339 break
9340 }
9341 v.reset(Op386XORLconstmodifyidx4)
9342 v.AuxInt = makeValAndOff(c, off)
9343 v.Aux = sym
9344 v.AddArg(ptr)
9345 v.AddArg(idx)
9346 v.AddArg(mem)
9347 return true
9348 }
9349 return false
9350 }
9351 func rewriteValue386_Op386MOVSDconst_0(v *Value) bool {
9352 b := v.Block
9353 config := b.Func.Config
9354 typ := &b.Func.Config.Types
9355
9356
9357
9358 for {
9359 c := v.AuxInt
9360 if !(config.ctxt.Flag_shared) {
9361 break
9362 }
9363 v.reset(Op386MOVSDconst2)
9364 v0 := b.NewValue0(v.Pos, Op386MOVSDconst1, typ.UInt32)
9365 v0.AuxInt = c
9366 v.AddArg(v0)
9367 return true
9368 }
9369 return false
9370 }
9371 func rewriteValue386_Op386MOVSDload_0(v *Value) bool {
9372 b := v.Block
9373 config := b.Func.Config
9374
9375
9376
9377 for {
9378 off1 := v.AuxInt
9379 sym := v.Aux
9380 mem := v.Args[1]
9381 v_0 := v.Args[0]
9382 if v_0.Op != Op386ADDLconst {
9383 break
9384 }
9385 off2 := v_0.AuxInt
9386 ptr := v_0.Args[0]
9387 if !(is32Bit(off1 + off2)) {
9388 break
9389 }
9390 v.reset(Op386MOVSDload)
9391 v.AuxInt = off1 + off2
9392 v.Aux = sym
9393 v.AddArg(ptr)
9394 v.AddArg(mem)
9395 return true
9396 }
9397
9398
9399
9400 for {
9401 off1 := v.AuxInt
9402 sym1 := v.Aux
9403 mem := v.Args[1]
9404 v_0 := v.Args[0]
9405 if v_0.Op != Op386LEAL {
9406 break
9407 }
9408 off2 := v_0.AuxInt
9409 sym2 := v_0.Aux
9410 base := v_0.Args[0]
9411 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
9412 break
9413 }
9414 v.reset(Op386MOVSDload)
9415 v.AuxInt = off1 + off2
9416 v.Aux = mergeSym(sym1, sym2)
9417 v.AddArg(base)
9418 v.AddArg(mem)
9419 return true
9420 }
9421
9422
9423
9424 for {
9425 off1 := v.AuxInt
9426 sym1 := v.Aux
9427 mem := v.Args[1]
9428 v_0 := v.Args[0]
9429 if v_0.Op != Op386LEAL1 {
9430 break
9431 }
9432 off2 := v_0.AuxInt
9433 sym2 := v_0.Aux
9434 idx := v_0.Args[1]
9435 ptr := v_0.Args[0]
9436 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
9437 break
9438 }
9439 v.reset(Op386MOVSDloadidx1)
9440 v.AuxInt = off1 + off2
9441 v.Aux = mergeSym(sym1, sym2)
9442 v.AddArg(ptr)
9443 v.AddArg(idx)
9444 v.AddArg(mem)
9445 return true
9446 }
9447
9448
9449
9450 for {
9451 off1 := v.AuxInt
9452 sym1 := v.Aux
9453 mem := v.Args[1]
9454 v_0 := v.Args[0]
9455 if v_0.Op != Op386LEAL8 {
9456 break
9457 }
9458 off2 := v_0.AuxInt
9459 sym2 := v_0.Aux
9460 idx := v_0.Args[1]
9461 ptr := v_0.Args[0]
9462 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
9463 break
9464 }
9465 v.reset(Op386MOVSDloadidx8)
9466 v.AuxInt = off1 + off2
9467 v.Aux = mergeSym(sym1, sym2)
9468 v.AddArg(ptr)
9469 v.AddArg(idx)
9470 v.AddArg(mem)
9471 return true
9472 }
9473
9474
9475
9476 for {
9477 off := v.AuxInt
9478 sym := v.Aux
9479 mem := v.Args[1]
9480 v_0 := v.Args[0]
9481 if v_0.Op != Op386ADDL {
9482 break
9483 }
9484 idx := v_0.Args[1]
9485 ptr := v_0.Args[0]
9486 if !(ptr.Op != OpSB) {
9487 break
9488 }
9489 v.reset(Op386MOVSDloadidx1)
9490 v.AuxInt = off
9491 v.Aux = sym
9492 v.AddArg(ptr)
9493 v.AddArg(idx)
9494 v.AddArg(mem)
9495 return true
9496 }
9497 return false
9498 }
9499 func rewriteValue386_Op386MOVSDloadidx1_0(v *Value) bool {
9500
9501
9502
9503 for {
9504 c := v.AuxInt
9505 sym := v.Aux
9506 mem := v.Args[2]
9507 v_0 := v.Args[0]
9508 if v_0.Op != Op386ADDLconst {
9509 break
9510 }
9511 d := v_0.AuxInt
9512 ptr := v_0.Args[0]
9513 idx := v.Args[1]
9514 v.reset(Op386MOVSDloadidx1)
9515 v.AuxInt = int64(int32(c + d))
9516 v.Aux = sym
9517 v.AddArg(ptr)
9518 v.AddArg(idx)
9519 v.AddArg(mem)
9520 return true
9521 }
9522
9523
9524
9525 for {
9526 c := v.AuxInt
9527 sym := v.Aux
9528 mem := v.Args[2]
9529 ptr := v.Args[0]
9530 v_1 := v.Args[1]
9531 if v_1.Op != Op386ADDLconst {
9532 break
9533 }
9534 d := v_1.AuxInt
9535 idx := v_1.Args[0]
9536 v.reset(Op386MOVSDloadidx1)
9537 v.AuxInt = int64(int32(c + d))
9538 v.Aux = sym
9539 v.AddArg(ptr)
9540 v.AddArg(idx)
9541 v.AddArg(mem)
9542 return true
9543 }
9544 return false
9545 }
9546 func rewriteValue386_Op386MOVSDloadidx8_0(v *Value) bool {
9547
9548
9549
9550 for {
9551 c := v.AuxInt
9552 sym := v.Aux
9553 mem := v.Args[2]
9554 v_0 := v.Args[0]
9555 if v_0.Op != Op386ADDLconst {
9556 break
9557 }
9558 d := v_0.AuxInt
9559 ptr := v_0.Args[0]
9560 idx := v.Args[1]
9561 v.reset(Op386MOVSDloadidx8)
9562 v.AuxInt = int64(int32(c + d))
9563 v.Aux = sym
9564 v.AddArg(ptr)
9565 v.AddArg(idx)
9566 v.AddArg(mem)
9567 return true
9568 }
9569
9570
9571
9572 for {
9573 c := v.AuxInt
9574 sym := v.Aux
9575 mem := v.Args[2]
9576 ptr := v.Args[0]
9577 v_1 := v.Args[1]
9578 if v_1.Op != Op386ADDLconst {
9579 break
9580 }
9581 d := v_1.AuxInt
9582 idx := v_1.Args[0]
9583 v.reset(Op386MOVSDloadidx8)
9584 v.AuxInt = int64(int32(c + 8*d))
9585 v.Aux = sym
9586 v.AddArg(ptr)
9587 v.AddArg(idx)
9588 v.AddArg(mem)
9589 return true
9590 }
9591 return false
9592 }
9593 func rewriteValue386_Op386MOVSDstore_0(v *Value) bool {
9594 b := v.Block
9595 config := b.Func.Config
9596
9597
9598
9599 for {
9600 off1 := v.AuxInt
9601 sym := v.Aux
9602 mem := v.Args[2]
9603 v_0 := v.Args[0]
9604 if v_0.Op != Op386ADDLconst {
9605 break
9606 }
9607 off2 := v_0.AuxInt
9608 ptr := v_0.Args[0]
9609 val := v.Args[1]
9610 if !(is32Bit(off1 + off2)) {
9611 break
9612 }
9613 v.reset(Op386MOVSDstore)
9614 v.AuxInt = off1 + off2
9615 v.Aux = sym
9616 v.AddArg(ptr)
9617 v.AddArg(val)
9618 v.AddArg(mem)
9619 return true
9620 }
9621
9622
9623
9624 for {
9625 off1 := v.AuxInt
9626 sym1 := v.Aux
9627 mem := v.Args[2]
9628 v_0 := v.Args[0]
9629 if v_0.Op != Op386LEAL {
9630 break
9631 }
9632 off2 := v_0.AuxInt
9633 sym2 := v_0.Aux
9634 base := v_0.Args[0]
9635 val := v.Args[1]
9636 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
9637 break
9638 }
9639 v.reset(Op386MOVSDstore)
9640 v.AuxInt = off1 + off2
9641 v.Aux = mergeSym(sym1, sym2)
9642 v.AddArg(base)
9643 v.AddArg(val)
9644 v.AddArg(mem)
9645 return true
9646 }
9647
9648
9649
9650 for {
9651 off1 := v.AuxInt
9652 sym1 := v.Aux
9653 mem := v.Args[2]
9654 v_0 := v.Args[0]
9655 if v_0.Op != Op386LEAL1 {
9656 break
9657 }
9658 off2 := v_0.AuxInt
9659 sym2 := v_0.Aux
9660 idx := v_0.Args[1]
9661 ptr := v_0.Args[0]
9662 val := v.Args[1]
9663 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
9664 break
9665 }
9666 v.reset(Op386MOVSDstoreidx1)
9667 v.AuxInt = off1 + off2
9668 v.Aux = mergeSym(sym1, sym2)
9669 v.AddArg(ptr)
9670 v.AddArg(idx)
9671 v.AddArg(val)
9672 v.AddArg(mem)
9673 return true
9674 }
9675
9676
9677
9678 for {
9679 off1 := v.AuxInt
9680 sym1 := v.Aux
9681 mem := v.Args[2]
9682 v_0 := v.Args[0]
9683 if v_0.Op != Op386LEAL8 {
9684 break
9685 }
9686 off2 := v_0.AuxInt
9687 sym2 := v_0.Aux
9688 idx := v_0.Args[1]
9689 ptr := v_0.Args[0]
9690 val := v.Args[1]
9691 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
9692 break
9693 }
9694 v.reset(Op386MOVSDstoreidx8)
9695 v.AuxInt = off1 + off2
9696 v.Aux = mergeSym(sym1, sym2)
9697 v.AddArg(ptr)
9698 v.AddArg(idx)
9699 v.AddArg(val)
9700 v.AddArg(mem)
9701 return true
9702 }
9703
9704
9705
9706 for {
9707 off := v.AuxInt
9708 sym := v.Aux
9709 mem := v.Args[2]
9710 v_0 := v.Args[0]
9711 if v_0.Op != Op386ADDL {
9712 break
9713 }
9714 idx := v_0.Args[1]
9715 ptr := v_0.Args[0]
9716 val := v.Args[1]
9717 if !(ptr.Op != OpSB) {
9718 break
9719 }
9720 v.reset(Op386MOVSDstoreidx1)
9721 v.AuxInt = off
9722 v.Aux = sym
9723 v.AddArg(ptr)
9724 v.AddArg(idx)
9725 v.AddArg(val)
9726 v.AddArg(mem)
9727 return true
9728 }
9729 return false
9730 }
9731 func rewriteValue386_Op386MOVSDstoreidx1_0(v *Value) bool {
9732
9733
9734
9735 for {
9736 c := v.AuxInt
9737 sym := v.Aux
9738 mem := v.Args[3]
9739 v_0 := v.Args[0]
9740 if v_0.Op != Op386ADDLconst {
9741 break
9742 }
9743 d := v_0.AuxInt
9744 ptr := v_0.Args[0]
9745 idx := v.Args[1]
9746 val := v.Args[2]
9747 v.reset(Op386MOVSDstoreidx1)
9748 v.AuxInt = int64(int32(c + d))
9749 v.Aux = sym
9750 v.AddArg(ptr)
9751 v.AddArg(idx)
9752 v.AddArg(val)
9753 v.AddArg(mem)
9754 return true
9755 }
9756
9757
9758
9759 for {
9760 c := v.AuxInt
9761 sym := v.Aux
9762 mem := v.Args[3]
9763 ptr := v.Args[0]
9764 v_1 := v.Args[1]
9765 if v_1.Op != Op386ADDLconst {
9766 break
9767 }
9768 d := v_1.AuxInt
9769 idx := v_1.Args[0]
9770 val := v.Args[2]
9771 v.reset(Op386MOVSDstoreidx1)
9772 v.AuxInt = int64(int32(c + d))
9773 v.Aux = sym
9774 v.AddArg(ptr)
9775 v.AddArg(idx)
9776 v.AddArg(val)
9777 v.AddArg(mem)
9778 return true
9779 }
9780 return false
9781 }
9782 func rewriteValue386_Op386MOVSDstoreidx8_0(v *Value) bool {
9783
9784
9785
9786 for {
9787 c := v.AuxInt
9788 sym := v.Aux
9789 mem := v.Args[3]
9790 v_0 := v.Args[0]
9791 if v_0.Op != Op386ADDLconst {
9792 break
9793 }
9794 d := v_0.AuxInt
9795 ptr := v_0.Args[0]
9796 idx := v.Args[1]
9797 val := v.Args[2]
9798 v.reset(Op386MOVSDstoreidx8)
9799 v.AuxInt = int64(int32(c + d))
9800 v.Aux = sym
9801 v.AddArg(ptr)
9802 v.AddArg(idx)
9803 v.AddArg(val)
9804 v.AddArg(mem)
9805 return true
9806 }
9807
9808
9809
9810 for {
9811 c := v.AuxInt
9812 sym := v.Aux
9813 mem := v.Args[3]
9814 ptr := v.Args[0]
9815 v_1 := v.Args[1]
9816 if v_1.Op != Op386ADDLconst {
9817 break
9818 }
9819 d := v_1.AuxInt
9820 idx := v_1.Args[0]
9821 val := v.Args[2]
9822 v.reset(Op386MOVSDstoreidx8)
9823 v.AuxInt = int64(int32(c + 8*d))
9824 v.Aux = sym
9825 v.AddArg(ptr)
9826 v.AddArg(idx)
9827 v.AddArg(val)
9828 v.AddArg(mem)
9829 return true
9830 }
9831 return false
9832 }
9833 func rewriteValue386_Op386MOVSSconst_0(v *Value) bool {
9834 b := v.Block
9835 config := b.Func.Config
9836 typ := &b.Func.Config.Types
9837
9838
9839
9840 for {
9841 c := v.AuxInt
9842 if !(config.ctxt.Flag_shared) {
9843 break
9844 }
9845 v.reset(Op386MOVSSconst2)
9846 v0 := b.NewValue0(v.Pos, Op386MOVSSconst1, typ.UInt32)
9847 v0.AuxInt = c
9848 v.AddArg(v0)
9849 return true
9850 }
9851 return false
9852 }
9853 func rewriteValue386_Op386MOVSSload_0(v *Value) bool {
9854 b := v.Block
9855 config := b.Func.Config
9856
9857
9858
9859 for {
9860 off1 := v.AuxInt
9861 sym := v.Aux
9862 mem := v.Args[1]
9863 v_0 := v.Args[0]
9864 if v_0.Op != Op386ADDLconst {
9865 break
9866 }
9867 off2 := v_0.AuxInt
9868 ptr := v_0.Args[0]
9869 if !(is32Bit(off1 + off2)) {
9870 break
9871 }
9872 v.reset(Op386MOVSSload)
9873 v.AuxInt = off1 + off2
9874 v.Aux = sym
9875 v.AddArg(ptr)
9876 v.AddArg(mem)
9877 return true
9878 }
9879
9880
9881
9882 for {
9883 off1 := v.AuxInt
9884 sym1 := v.Aux
9885 mem := v.Args[1]
9886 v_0 := v.Args[0]
9887 if v_0.Op != Op386LEAL {
9888 break
9889 }
9890 off2 := v_0.AuxInt
9891 sym2 := v_0.Aux
9892 base := v_0.Args[0]
9893 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
9894 break
9895 }
9896 v.reset(Op386MOVSSload)
9897 v.AuxInt = off1 + off2
9898 v.Aux = mergeSym(sym1, sym2)
9899 v.AddArg(base)
9900 v.AddArg(mem)
9901 return true
9902 }
9903
9904
9905
9906 for {
9907 off1 := v.AuxInt
9908 sym1 := v.Aux
9909 mem := v.Args[1]
9910 v_0 := v.Args[0]
9911 if v_0.Op != Op386LEAL1 {
9912 break
9913 }
9914 off2 := v_0.AuxInt
9915 sym2 := v_0.Aux
9916 idx := v_0.Args[1]
9917 ptr := v_0.Args[0]
9918 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
9919 break
9920 }
9921 v.reset(Op386MOVSSloadidx1)
9922 v.AuxInt = off1 + off2
9923 v.Aux = mergeSym(sym1, sym2)
9924 v.AddArg(ptr)
9925 v.AddArg(idx)
9926 v.AddArg(mem)
9927 return true
9928 }
9929
9930
9931
9932 for {
9933 off1 := v.AuxInt
9934 sym1 := v.Aux
9935 mem := v.Args[1]
9936 v_0 := v.Args[0]
9937 if v_0.Op != Op386LEAL4 {
9938 break
9939 }
9940 off2 := v_0.AuxInt
9941 sym2 := v_0.Aux
9942 idx := v_0.Args[1]
9943 ptr := v_0.Args[0]
9944 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
9945 break
9946 }
9947 v.reset(Op386MOVSSloadidx4)
9948 v.AuxInt = off1 + off2
9949 v.Aux = mergeSym(sym1, sym2)
9950 v.AddArg(ptr)
9951 v.AddArg(idx)
9952 v.AddArg(mem)
9953 return true
9954 }
9955
9956
9957
9958 for {
9959 off := v.AuxInt
9960 sym := v.Aux
9961 mem := v.Args[1]
9962 v_0 := v.Args[0]
9963 if v_0.Op != Op386ADDL {
9964 break
9965 }
9966 idx := v_0.Args[1]
9967 ptr := v_0.Args[0]
9968 if !(ptr.Op != OpSB) {
9969 break
9970 }
9971 v.reset(Op386MOVSSloadidx1)
9972 v.AuxInt = off
9973 v.Aux = sym
9974 v.AddArg(ptr)
9975 v.AddArg(idx)
9976 v.AddArg(mem)
9977 return true
9978 }
9979 return false
9980 }
9981 func rewriteValue386_Op386MOVSSloadidx1_0(v *Value) bool {
9982
9983
9984
9985 for {
9986 c := v.AuxInt
9987 sym := v.Aux
9988 mem := v.Args[2]
9989 v_0 := v.Args[0]
9990 if v_0.Op != Op386ADDLconst {
9991 break
9992 }
9993 d := v_0.AuxInt
9994 ptr := v_0.Args[0]
9995 idx := v.Args[1]
9996 v.reset(Op386MOVSSloadidx1)
9997 v.AuxInt = int64(int32(c + d))
9998 v.Aux = sym
9999 v.AddArg(ptr)
10000 v.AddArg(idx)
10001 v.AddArg(mem)
10002 return true
10003 }
10004
10005
10006
10007 for {
10008 c := v.AuxInt
10009 sym := v.Aux
10010 mem := v.Args[2]
10011 ptr := v.Args[0]
10012 v_1 := v.Args[1]
10013 if v_1.Op != Op386ADDLconst {
10014 break
10015 }
10016 d := v_1.AuxInt
10017 idx := v_1.Args[0]
10018 v.reset(Op386MOVSSloadidx1)
10019 v.AuxInt = int64(int32(c + d))
10020 v.Aux = sym
10021 v.AddArg(ptr)
10022 v.AddArg(idx)
10023 v.AddArg(mem)
10024 return true
10025 }
10026 return false
10027 }
10028 func rewriteValue386_Op386MOVSSloadidx4_0(v *Value) bool {
10029
10030
10031
10032 for {
10033 c := v.AuxInt
10034 sym := v.Aux
10035 mem := v.Args[2]
10036 v_0 := v.Args[0]
10037 if v_0.Op != Op386ADDLconst {
10038 break
10039 }
10040 d := v_0.AuxInt
10041 ptr := v_0.Args[0]
10042 idx := v.Args[1]
10043 v.reset(Op386MOVSSloadidx4)
10044 v.AuxInt = int64(int32(c + d))
10045 v.Aux = sym
10046 v.AddArg(ptr)
10047 v.AddArg(idx)
10048 v.AddArg(mem)
10049 return true
10050 }
10051
10052
10053
10054 for {
10055 c := v.AuxInt
10056 sym := v.Aux
10057 mem := v.Args[2]
10058 ptr := v.Args[0]
10059 v_1 := v.Args[1]
10060 if v_1.Op != Op386ADDLconst {
10061 break
10062 }
10063 d := v_1.AuxInt
10064 idx := v_1.Args[0]
10065 v.reset(Op386MOVSSloadidx4)
10066 v.AuxInt = int64(int32(c + 4*d))
10067 v.Aux = sym
10068 v.AddArg(ptr)
10069 v.AddArg(idx)
10070 v.AddArg(mem)
10071 return true
10072 }
10073 return false
10074 }
10075 func rewriteValue386_Op386MOVSSstore_0(v *Value) bool {
10076 b := v.Block
10077 config := b.Func.Config
10078
10079
10080
10081 for {
10082 off1 := v.AuxInt
10083 sym := v.Aux
10084 mem := v.Args[2]
10085 v_0 := v.Args[0]
10086 if v_0.Op != Op386ADDLconst {
10087 break
10088 }
10089 off2 := v_0.AuxInt
10090 ptr := v_0.Args[0]
10091 val := v.Args[1]
10092 if !(is32Bit(off1 + off2)) {
10093 break
10094 }
10095 v.reset(Op386MOVSSstore)
10096 v.AuxInt = off1 + off2
10097 v.Aux = sym
10098 v.AddArg(ptr)
10099 v.AddArg(val)
10100 v.AddArg(mem)
10101 return true
10102 }
10103
10104
10105
10106 for {
10107 off1 := v.AuxInt
10108 sym1 := v.Aux
10109 mem := v.Args[2]
10110 v_0 := v.Args[0]
10111 if v_0.Op != Op386LEAL {
10112 break
10113 }
10114 off2 := v_0.AuxInt
10115 sym2 := v_0.Aux
10116 base := v_0.Args[0]
10117 val := v.Args[1]
10118 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
10119 break
10120 }
10121 v.reset(Op386MOVSSstore)
10122 v.AuxInt = off1 + off2
10123 v.Aux = mergeSym(sym1, sym2)
10124 v.AddArg(base)
10125 v.AddArg(val)
10126 v.AddArg(mem)
10127 return true
10128 }
10129
10130
10131
10132 for {
10133 off1 := v.AuxInt
10134 sym1 := v.Aux
10135 mem := v.Args[2]
10136 v_0 := v.Args[0]
10137 if v_0.Op != Op386LEAL1 {
10138 break
10139 }
10140 off2 := v_0.AuxInt
10141 sym2 := v_0.Aux
10142 idx := v_0.Args[1]
10143 ptr := v_0.Args[0]
10144 val := v.Args[1]
10145 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
10146 break
10147 }
10148 v.reset(Op386MOVSSstoreidx1)
10149 v.AuxInt = off1 + off2
10150 v.Aux = mergeSym(sym1, sym2)
10151 v.AddArg(ptr)
10152 v.AddArg(idx)
10153 v.AddArg(val)
10154 v.AddArg(mem)
10155 return true
10156 }
10157
10158
10159
10160 for {
10161 off1 := v.AuxInt
10162 sym1 := v.Aux
10163 mem := v.Args[2]
10164 v_0 := v.Args[0]
10165 if v_0.Op != Op386LEAL4 {
10166 break
10167 }
10168 off2 := v_0.AuxInt
10169 sym2 := v_0.Aux
10170 idx := v_0.Args[1]
10171 ptr := v_0.Args[0]
10172 val := v.Args[1]
10173 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
10174 break
10175 }
10176 v.reset(Op386MOVSSstoreidx4)
10177 v.AuxInt = off1 + off2
10178 v.Aux = mergeSym(sym1, sym2)
10179 v.AddArg(ptr)
10180 v.AddArg(idx)
10181 v.AddArg(val)
10182 v.AddArg(mem)
10183 return true
10184 }
10185
10186
10187
10188 for {
10189 off := v.AuxInt
10190 sym := v.Aux
10191 mem := v.Args[2]
10192 v_0 := v.Args[0]
10193 if v_0.Op != Op386ADDL {
10194 break
10195 }
10196 idx := v_0.Args[1]
10197 ptr := v_0.Args[0]
10198 val := v.Args[1]
10199 if !(ptr.Op != OpSB) {
10200 break
10201 }
10202 v.reset(Op386MOVSSstoreidx1)
10203 v.AuxInt = off
10204 v.Aux = sym
10205 v.AddArg(ptr)
10206 v.AddArg(idx)
10207 v.AddArg(val)
10208 v.AddArg(mem)
10209 return true
10210 }
10211 return false
10212 }
10213 func rewriteValue386_Op386MOVSSstoreidx1_0(v *Value) bool {
10214
10215
10216
10217 for {
10218 c := v.AuxInt
10219 sym := v.Aux
10220 mem := v.Args[3]
10221 v_0 := v.Args[0]
10222 if v_0.Op != Op386ADDLconst {
10223 break
10224 }
10225 d := v_0.AuxInt
10226 ptr := v_0.Args[0]
10227 idx := v.Args[1]
10228 val := v.Args[2]
10229 v.reset(Op386MOVSSstoreidx1)
10230 v.AuxInt = int64(int32(c + d))
10231 v.Aux = sym
10232 v.AddArg(ptr)
10233 v.AddArg(idx)
10234 v.AddArg(val)
10235 v.AddArg(mem)
10236 return true
10237 }
10238
10239
10240
10241 for {
10242 c := v.AuxInt
10243 sym := v.Aux
10244 mem := v.Args[3]
10245 ptr := v.Args[0]
10246 v_1 := v.Args[1]
10247 if v_1.Op != Op386ADDLconst {
10248 break
10249 }
10250 d := v_1.AuxInt
10251 idx := v_1.Args[0]
10252 val := v.Args[2]
10253 v.reset(Op386MOVSSstoreidx1)
10254 v.AuxInt = int64(int32(c + d))
10255 v.Aux = sym
10256 v.AddArg(ptr)
10257 v.AddArg(idx)
10258 v.AddArg(val)
10259 v.AddArg(mem)
10260 return true
10261 }
10262 return false
10263 }
10264 func rewriteValue386_Op386MOVSSstoreidx4_0(v *Value) bool {
10265
10266
10267
10268 for {
10269 c := v.AuxInt
10270 sym := v.Aux
10271 mem := v.Args[3]
10272 v_0 := v.Args[0]
10273 if v_0.Op != Op386ADDLconst {
10274 break
10275 }
10276 d := v_0.AuxInt
10277 ptr := v_0.Args[0]
10278 idx := v.Args[1]
10279 val := v.Args[2]
10280 v.reset(Op386MOVSSstoreidx4)
10281 v.AuxInt = int64(int32(c + d))
10282 v.Aux = sym
10283 v.AddArg(ptr)
10284 v.AddArg(idx)
10285 v.AddArg(val)
10286 v.AddArg(mem)
10287 return true
10288 }
10289
10290
10291
10292 for {
10293 c := v.AuxInt
10294 sym := v.Aux
10295 mem := v.Args[3]
10296 ptr := v.Args[0]
10297 v_1 := v.Args[1]
10298 if v_1.Op != Op386ADDLconst {
10299 break
10300 }
10301 d := v_1.AuxInt
10302 idx := v_1.Args[0]
10303 val := v.Args[2]
10304 v.reset(Op386MOVSSstoreidx4)
10305 v.AuxInt = int64(int32(c + 4*d))
10306 v.Aux = sym
10307 v.AddArg(ptr)
10308 v.AddArg(idx)
10309 v.AddArg(val)
10310 v.AddArg(mem)
10311 return true
10312 }
10313 return false
10314 }
10315 func rewriteValue386_Op386MOVWLSX_0(v *Value) bool {
10316 b := v.Block
10317
10318
10319
10320 for {
10321 x := v.Args[0]
10322 if x.Op != Op386MOVWload {
10323 break
10324 }
10325 off := x.AuxInt
10326 sym := x.Aux
10327 mem := x.Args[1]
10328 ptr := x.Args[0]
10329 if !(x.Uses == 1 && clobber(x)) {
10330 break
10331 }
10332 b = x.Block
10333 v0 := b.NewValue0(x.Pos, Op386MOVWLSXload, v.Type)
10334 v.reset(OpCopy)
10335 v.AddArg(v0)
10336 v0.AuxInt = off
10337 v0.Aux = sym
10338 v0.AddArg(ptr)
10339 v0.AddArg(mem)
10340 return true
10341 }
10342
10343
10344
10345 for {
10346 v_0 := v.Args[0]
10347 if v_0.Op != Op386ANDLconst {
10348 break
10349 }
10350 c := v_0.AuxInt
10351 x := v_0.Args[0]
10352 if !(c&0x8000 == 0) {
10353 break
10354 }
10355 v.reset(Op386ANDLconst)
10356 v.AuxInt = c & 0x7fff
10357 v.AddArg(x)
10358 return true
10359 }
10360 return false
10361 }
10362 func rewriteValue386_Op386MOVWLSXload_0(v *Value) bool {
10363 b := v.Block
10364 config := b.Func.Config
10365
10366
10367
10368 for {
10369 off := v.AuxInt
10370 sym := v.Aux
10371 _ = v.Args[1]
10372 ptr := v.Args[0]
10373 v_1 := v.Args[1]
10374 if v_1.Op != Op386MOVWstore {
10375 break
10376 }
10377 off2 := v_1.AuxInt
10378 sym2 := v_1.Aux
10379 _ = v_1.Args[2]
10380 ptr2 := v_1.Args[0]
10381 x := v_1.Args[1]
10382 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
10383 break
10384 }
10385 v.reset(Op386MOVWLSX)
10386 v.AddArg(x)
10387 return true
10388 }
10389
10390
10391
10392 for {
10393 off1 := v.AuxInt
10394 sym1 := v.Aux
10395 mem := v.Args[1]
10396 v_0 := v.Args[0]
10397 if v_0.Op != Op386LEAL {
10398 break
10399 }
10400 off2 := v_0.AuxInt
10401 sym2 := v_0.Aux
10402 base := v_0.Args[0]
10403 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
10404 break
10405 }
10406 v.reset(Op386MOVWLSXload)
10407 v.AuxInt = off1 + off2
10408 v.Aux = mergeSym(sym1, sym2)
10409 v.AddArg(base)
10410 v.AddArg(mem)
10411 return true
10412 }
10413 return false
10414 }
10415 func rewriteValue386_Op386MOVWLZX_0(v *Value) bool {
10416 b := v.Block
10417
10418
10419
10420 for {
10421 x := v.Args[0]
10422 if x.Op != Op386MOVWload {
10423 break
10424 }
10425 off := x.AuxInt
10426 sym := x.Aux
10427 mem := x.Args[1]
10428 ptr := x.Args[0]
10429 if !(x.Uses == 1 && clobber(x)) {
10430 break
10431 }
10432 b = x.Block
10433 v0 := b.NewValue0(x.Pos, Op386MOVWload, v.Type)
10434 v.reset(OpCopy)
10435 v.AddArg(v0)
10436 v0.AuxInt = off
10437 v0.Aux = sym
10438 v0.AddArg(ptr)
10439 v0.AddArg(mem)
10440 return true
10441 }
10442
10443
10444
10445 for {
10446 x := v.Args[0]
10447 if x.Op != Op386MOVWloadidx1 {
10448 break
10449 }
10450 off := x.AuxInt
10451 sym := x.Aux
10452 mem := x.Args[2]
10453 ptr := x.Args[0]
10454 idx := x.Args[1]
10455 if !(x.Uses == 1 && clobber(x)) {
10456 break
10457 }
10458 b = x.Block
10459 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
10460 v.reset(OpCopy)
10461 v.AddArg(v0)
10462 v0.AuxInt = off
10463 v0.Aux = sym
10464 v0.AddArg(ptr)
10465 v0.AddArg(idx)
10466 v0.AddArg(mem)
10467 return true
10468 }
10469
10470
10471
10472 for {
10473 x := v.Args[0]
10474 if x.Op != Op386MOVWloadidx2 {
10475 break
10476 }
10477 off := x.AuxInt
10478 sym := x.Aux
10479 mem := x.Args[2]
10480 ptr := x.Args[0]
10481 idx := x.Args[1]
10482 if !(x.Uses == 1 && clobber(x)) {
10483 break
10484 }
10485 b = x.Block
10486 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx2, v.Type)
10487 v.reset(OpCopy)
10488 v.AddArg(v0)
10489 v0.AuxInt = off
10490 v0.Aux = sym
10491 v0.AddArg(ptr)
10492 v0.AddArg(idx)
10493 v0.AddArg(mem)
10494 return true
10495 }
10496
10497
10498
10499 for {
10500 v_0 := v.Args[0]
10501 if v_0.Op != Op386ANDLconst {
10502 break
10503 }
10504 c := v_0.AuxInt
10505 x := v_0.Args[0]
10506 v.reset(Op386ANDLconst)
10507 v.AuxInt = c & 0xffff
10508 v.AddArg(x)
10509 return true
10510 }
10511 return false
10512 }
10513 func rewriteValue386_Op386MOVWload_0(v *Value) bool {
10514 b := v.Block
10515 config := b.Func.Config
10516
10517
10518
10519 for {
10520 off := v.AuxInt
10521 sym := v.Aux
10522 _ = v.Args[1]
10523 ptr := v.Args[0]
10524 v_1 := v.Args[1]
10525 if v_1.Op != Op386MOVWstore {
10526 break
10527 }
10528 off2 := v_1.AuxInt
10529 sym2 := v_1.Aux
10530 _ = v_1.Args[2]
10531 ptr2 := v_1.Args[0]
10532 x := v_1.Args[1]
10533 if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
10534 break
10535 }
10536 v.reset(Op386MOVWLZX)
10537 v.AddArg(x)
10538 return true
10539 }
10540
10541
10542
10543 for {
10544 off1 := v.AuxInt
10545 sym := v.Aux
10546 mem := v.Args[1]
10547 v_0 := v.Args[0]
10548 if v_0.Op != Op386ADDLconst {
10549 break
10550 }
10551 off2 := v_0.AuxInt
10552 ptr := v_0.Args[0]
10553 if !(is32Bit(off1 + off2)) {
10554 break
10555 }
10556 v.reset(Op386MOVWload)
10557 v.AuxInt = off1 + off2
10558 v.Aux = sym
10559 v.AddArg(ptr)
10560 v.AddArg(mem)
10561 return true
10562 }
10563
10564
10565
10566 for {
10567 off1 := v.AuxInt
10568 sym1 := v.Aux
10569 mem := v.Args[1]
10570 v_0 := v.Args[0]
10571 if v_0.Op != Op386LEAL {
10572 break
10573 }
10574 off2 := v_0.AuxInt
10575 sym2 := v_0.Aux
10576 base := v_0.Args[0]
10577 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
10578 break
10579 }
10580 v.reset(Op386MOVWload)
10581 v.AuxInt = off1 + off2
10582 v.Aux = mergeSym(sym1, sym2)
10583 v.AddArg(base)
10584 v.AddArg(mem)
10585 return true
10586 }
10587
10588
10589
10590 for {
10591 off1 := v.AuxInt
10592 sym1 := v.Aux
10593 mem := v.Args[1]
10594 v_0 := v.Args[0]
10595 if v_0.Op != Op386LEAL1 {
10596 break
10597 }
10598 off2 := v_0.AuxInt
10599 sym2 := v_0.Aux
10600 idx := v_0.Args[1]
10601 ptr := v_0.Args[0]
10602 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
10603 break
10604 }
10605 v.reset(Op386MOVWloadidx1)
10606 v.AuxInt = off1 + off2
10607 v.Aux = mergeSym(sym1, sym2)
10608 v.AddArg(ptr)
10609 v.AddArg(idx)
10610 v.AddArg(mem)
10611 return true
10612 }
10613
10614
10615
10616 for {
10617 off1 := v.AuxInt
10618 sym1 := v.Aux
10619 mem := v.Args[1]
10620 v_0 := v.Args[0]
10621 if v_0.Op != Op386LEAL2 {
10622 break
10623 }
10624 off2 := v_0.AuxInt
10625 sym2 := v_0.Aux
10626 idx := v_0.Args[1]
10627 ptr := v_0.Args[0]
10628 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
10629 break
10630 }
10631 v.reset(Op386MOVWloadidx2)
10632 v.AuxInt = off1 + off2
10633 v.Aux = mergeSym(sym1, sym2)
10634 v.AddArg(ptr)
10635 v.AddArg(idx)
10636 v.AddArg(mem)
10637 return true
10638 }
10639
10640
10641
10642 for {
10643 off := v.AuxInt
10644 sym := v.Aux
10645 mem := v.Args[1]
10646 v_0 := v.Args[0]
10647 if v_0.Op != Op386ADDL {
10648 break
10649 }
10650 idx := v_0.Args[1]
10651 ptr := v_0.Args[0]
10652 if !(ptr.Op != OpSB) {
10653 break
10654 }
10655 v.reset(Op386MOVWloadidx1)
10656 v.AuxInt = off
10657 v.Aux = sym
10658 v.AddArg(ptr)
10659 v.AddArg(idx)
10660 v.AddArg(mem)
10661 return true
10662 }
10663
10664
10665
10666 for {
10667 off := v.AuxInt
10668 sym := v.Aux
10669 _ = v.Args[1]
10670 v_0 := v.Args[0]
10671 if v_0.Op != OpSB {
10672 break
10673 }
10674 if !(symIsRO(sym)) {
10675 break
10676 }
10677 v.reset(Op386MOVLconst)
10678 v.AuxInt = int64(read16(sym, off, config.BigEndian))
10679 return true
10680 }
10681 return false
10682 }
10683 func rewriteValue386_Op386MOVWloadidx1_0(v *Value) bool {
10684
10685
10686
10687 for {
10688 c := v.AuxInt
10689 sym := v.Aux
10690 mem := v.Args[2]
10691 ptr := v.Args[0]
10692 v_1 := v.Args[1]
10693 if v_1.Op != Op386SHLLconst {
10694 break
10695 }
10696 if v_1.AuxInt != 1 {
10697 break
10698 }
10699 idx := v_1.Args[0]
10700 v.reset(Op386MOVWloadidx2)
10701 v.AuxInt = c
10702 v.Aux = sym
10703 v.AddArg(ptr)
10704 v.AddArg(idx)
10705 v.AddArg(mem)
10706 return true
10707 }
10708
10709
10710
10711 for {
10712 c := v.AuxInt
10713 sym := v.Aux
10714 mem := v.Args[2]
10715 v_0 := v.Args[0]
10716 if v_0.Op != Op386SHLLconst {
10717 break
10718 }
10719 if v_0.AuxInt != 1 {
10720 break
10721 }
10722 idx := v_0.Args[0]
10723 ptr := v.Args[1]
10724 v.reset(Op386MOVWloadidx2)
10725 v.AuxInt = c
10726 v.Aux = sym
10727 v.AddArg(ptr)
10728 v.AddArg(idx)
10729 v.AddArg(mem)
10730 return true
10731 }
10732
10733
10734
10735 for {
10736 c := v.AuxInt
10737 sym := v.Aux
10738 mem := v.Args[2]
10739 v_0 := v.Args[0]
10740 if v_0.Op != Op386ADDLconst {
10741 break
10742 }
10743 d := v_0.AuxInt
10744 ptr := v_0.Args[0]
10745 idx := v.Args[1]
10746 v.reset(Op386MOVWloadidx1)
10747 v.AuxInt = int64(int32(c + d))
10748 v.Aux = sym
10749 v.AddArg(ptr)
10750 v.AddArg(idx)
10751 v.AddArg(mem)
10752 return true
10753 }
10754
10755
10756
10757 for {
10758 c := v.AuxInt
10759 sym := v.Aux
10760 mem := v.Args[2]
10761 idx := v.Args[0]
10762 v_1 := v.Args[1]
10763 if v_1.Op != Op386ADDLconst {
10764 break
10765 }
10766 d := v_1.AuxInt
10767 ptr := v_1.Args[0]
10768 v.reset(Op386MOVWloadidx1)
10769 v.AuxInt = int64(int32(c + d))
10770 v.Aux = sym
10771 v.AddArg(ptr)
10772 v.AddArg(idx)
10773 v.AddArg(mem)
10774 return true
10775 }
10776
10777
10778
10779 for {
10780 c := v.AuxInt
10781 sym := v.Aux
10782 mem := v.Args[2]
10783 ptr := v.Args[0]
10784 v_1 := v.Args[1]
10785 if v_1.Op != Op386ADDLconst {
10786 break
10787 }
10788 d := v_1.AuxInt
10789 idx := v_1.Args[0]
10790 v.reset(Op386MOVWloadidx1)
10791 v.AuxInt = int64(int32(c + d))
10792 v.Aux = sym
10793 v.AddArg(ptr)
10794 v.AddArg(idx)
10795 v.AddArg(mem)
10796 return true
10797 }
10798
10799
10800
10801 for {
10802 c := v.AuxInt
10803 sym := v.Aux
10804 mem := v.Args[2]
10805 v_0 := v.Args[0]
10806 if v_0.Op != Op386ADDLconst {
10807 break
10808 }
10809 d := v_0.AuxInt
10810 idx := v_0.Args[0]
10811 ptr := v.Args[1]
10812 v.reset(Op386MOVWloadidx1)
10813 v.AuxInt = int64(int32(c + d))
10814 v.Aux = sym
10815 v.AddArg(ptr)
10816 v.AddArg(idx)
10817 v.AddArg(mem)
10818 return true
10819 }
10820 return false
10821 }
10822 func rewriteValue386_Op386MOVWloadidx2_0(v *Value) bool {
10823
10824
10825
10826 for {
10827 c := v.AuxInt
10828 sym := v.Aux
10829 mem := v.Args[2]
10830 v_0 := v.Args[0]
10831 if v_0.Op != Op386ADDLconst {
10832 break
10833 }
10834 d := v_0.AuxInt
10835 ptr := v_0.Args[0]
10836 idx := v.Args[1]
10837 v.reset(Op386MOVWloadidx2)
10838 v.AuxInt = int64(int32(c + d))
10839 v.Aux = sym
10840 v.AddArg(ptr)
10841 v.AddArg(idx)
10842 v.AddArg(mem)
10843 return true
10844 }
10845
10846
10847
10848 for {
10849 c := v.AuxInt
10850 sym := v.Aux
10851 mem := v.Args[2]
10852 ptr := v.Args[0]
10853 v_1 := v.Args[1]
10854 if v_1.Op != Op386ADDLconst {
10855 break
10856 }
10857 d := v_1.AuxInt
10858 idx := v_1.Args[0]
10859 v.reset(Op386MOVWloadidx2)
10860 v.AuxInt = int64(int32(c + 2*d))
10861 v.Aux = sym
10862 v.AddArg(ptr)
10863 v.AddArg(idx)
10864 v.AddArg(mem)
10865 return true
10866 }
10867 return false
10868 }
10869 func rewriteValue386_Op386MOVWstore_0(v *Value) bool {
10870 b := v.Block
10871 config := b.Func.Config
10872
10873
10874
10875 for {
10876 off := v.AuxInt
10877 sym := v.Aux
10878 mem := v.Args[2]
10879 ptr := v.Args[0]
10880 v_1 := v.Args[1]
10881 if v_1.Op != Op386MOVWLSX {
10882 break
10883 }
10884 x := v_1.Args[0]
10885 v.reset(Op386MOVWstore)
10886 v.AuxInt = off
10887 v.Aux = sym
10888 v.AddArg(ptr)
10889 v.AddArg(x)
10890 v.AddArg(mem)
10891 return true
10892 }
10893
10894
10895
10896 for {
10897 off := v.AuxInt
10898 sym := v.Aux
10899 mem := v.Args[2]
10900 ptr := v.Args[0]
10901 v_1 := v.Args[1]
10902 if v_1.Op != Op386MOVWLZX {
10903 break
10904 }
10905 x := v_1.Args[0]
10906 v.reset(Op386MOVWstore)
10907 v.AuxInt = off
10908 v.Aux = sym
10909 v.AddArg(ptr)
10910 v.AddArg(x)
10911 v.AddArg(mem)
10912 return true
10913 }
10914
10915
10916
10917 for {
10918 off1 := v.AuxInt
10919 sym := v.Aux
10920 mem := v.Args[2]
10921 v_0 := v.Args[0]
10922 if v_0.Op != Op386ADDLconst {
10923 break
10924 }
10925 off2 := v_0.AuxInt
10926 ptr := v_0.Args[0]
10927 val := v.Args[1]
10928 if !(is32Bit(off1 + off2)) {
10929 break
10930 }
10931 v.reset(Op386MOVWstore)
10932 v.AuxInt = off1 + off2
10933 v.Aux = sym
10934 v.AddArg(ptr)
10935 v.AddArg(val)
10936 v.AddArg(mem)
10937 return true
10938 }
10939
10940
10941
10942 for {
10943 off := v.AuxInt
10944 sym := v.Aux
10945 mem := v.Args[2]
10946 ptr := v.Args[0]
10947 v_1 := v.Args[1]
10948 if v_1.Op != Op386MOVLconst {
10949 break
10950 }
10951 c := v_1.AuxInt
10952 if !(validOff(off)) {
10953 break
10954 }
10955 v.reset(Op386MOVWstoreconst)
10956 v.AuxInt = makeValAndOff(int64(int16(c)), off)
10957 v.Aux = sym
10958 v.AddArg(ptr)
10959 v.AddArg(mem)
10960 return true
10961 }
10962
10963
10964
10965 for {
10966 off1 := v.AuxInt
10967 sym1 := v.Aux
10968 mem := v.Args[2]
10969 v_0 := v.Args[0]
10970 if v_0.Op != Op386LEAL {
10971 break
10972 }
10973 off2 := v_0.AuxInt
10974 sym2 := v_0.Aux
10975 base := v_0.Args[0]
10976 val := v.Args[1]
10977 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
10978 break
10979 }
10980 v.reset(Op386MOVWstore)
10981 v.AuxInt = off1 + off2
10982 v.Aux = mergeSym(sym1, sym2)
10983 v.AddArg(base)
10984 v.AddArg(val)
10985 v.AddArg(mem)
10986 return true
10987 }
10988
10989
10990
10991 for {
10992 off1 := v.AuxInt
10993 sym1 := v.Aux
10994 mem := v.Args[2]
10995 v_0 := v.Args[0]
10996 if v_0.Op != Op386LEAL1 {
10997 break
10998 }
10999 off2 := v_0.AuxInt
11000 sym2 := v_0.Aux
11001 idx := v_0.Args[1]
11002 ptr := v_0.Args[0]
11003 val := v.Args[1]
11004 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
11005 break
11006 }
11007 v.reset(Op386MOVWstoreidx1)
11008 v.AuxInt = off1 + off2
11009 v.Aux = mergeSym(sym1, sym2)
11010 v.AddArg(ptr)
11011 v.AddArg(idx)
11012 v.AddArg(val)
11013 v.AddArg(mem)
11014 return true
11015 }
11016
11017
11018
11019 for {
11020 off1 := v.AuxInt
11021 sym1 := v.Aux
11022 mem := v.Args[2]
11023 v_0 := v.Args[0]
11024 if v_0.Op != Op386LEAL2 {
11025 break
11026 }
11027 off2 := v_0.AuxInt
11028 sym2 := v_0.Aux
11029 idx := v_0.Args[1]
11030 ptr := v_0.Args[0]
11031 val := v.Args[1]
11032 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
11033 break
11034 }
11035 v.reset(Op386MOVWstoreidx2)
11036 v.AuxInt = off1 + off2
11037 v.Aux = mergeSym(sym1, sym2)
11038 v.AddArg(ptr)
11039 v.AddArg(idx)
11040 v.AddArg(val)
11041 v.AddArg(mem)
11042 return true
11043 }
11044
11045
11046
11047 for {
11048 off := v.AuxInt
11049 sym := v.Aux
11050 mem := v.Args[2]
11051 v_0 := v.Args[0]
11052 if v_0.Op != Op386ADDL {
11053 break
11054 }
11055 idx := v_0.Args[1]
11056 ptr := v_0.Args[0]
11057 val := v.Args[1]
11058 if !(ptr.Op != OpSB) {
11059 break
11060 }
11061 v.reset(Op386MOVWstoreidx1)
11062 v.AuxInt = off
11063 v.Aux = sym
11064 v.AddArg(ptr)
11065 v.AddArg(idx)
11066 v.AddArg(val)
11067 v.AddArg(mem)
11068 return true
11069 }
11070
11071
11072
11073 for {
11074 i := v.AuxInt
11075 s := v.Aux
11076 _ = v.Args[2]
11077 p := v.Args[0]
11078 v_1 := v.Args[1]
11079 if v_1.Op != Op386SHRLconst {
11080 break
11081 }
11082 if v_1.AuxInt != 16 {
11083 break
11084 }
11085 w := v_1.Args[0]
11086 x := v.Args[2]
11087 if x.Op != Op386MOVWstore {
11088 break
11089 }
11090 if x.AuxInt != i-2 {
11091 break
11092 }
11093 if x.Aux != s {
11094 break
11095 }
11096 mem := x.Args[2]
11097 if p != x.Args[0] {
11098 break
11099 }
11100 if w != x.Args[1] {
11101 break
11102 }
11103 if !(x.Uses == 1 && clobber(x)) {
11104 break
11105 }
11106 v.reset(Op386MOVLstore)
11107 v.AuxInt = i - 2
11108 v.Aux = s
11109 v.AddArg(p)
11110 v.AddArg(w)
11111 v.AddArg(mem)
11112 return true
11113 }
11114
11115
11116
11117 for {
11118 i := v.AuxInt
11119 s := v.Aux
11120 _ = v.Args[2]
11121 p := v.Args[0]
11122 v_1 := v.Args[1]
11123 if v_1.Op != Op386SHRLconst {
11124 break
11125 }
11126 j := v_1.AuxInt
11127 w := v_1.Args[0]
11128 x := v.Args[2]
11129 if x.Op != Op386MOVWstore {
11130 break
11131 }
11132 if x.AuxInt != i-2 {
11133 break
11134 }
11135 if x.Aux != s {
11136 break
11137 }
11138 mem := x.Args[2]
11139 if p != x.Args[0] {
11140 break
11141 }
11142 w0 := x.Args[1]
11143 if w0.Op != Op386SHRLconst {
11144 break
11145 }
11146 if w0.AuxInt != j-16 {
11147 break
11148 }
11149 if w != w0.Args[0] {
11150 break
11151 }
11152 if !(x.Uses == 1 && clobber(x)) {
11153 break
11154 }
11155 v.reset(Op386MOVLstore)
11156 v.AuxInt = i - 2
11157 v.Aux = s
11158 v.AddArg(p)
11159 v.AddArg(w0)
11160 v.AddArg(mem)
11161 return true
11162 }
11163 return false
11164 }
11165 func rewriteValue386_Op386MOVWstoreconst_0(v *Value) bool {
11166 b := v.Block
11167 config := b.Func.Config
11168
11169
11170
11171 for {
11172 sc := v.AuxInt
11173 s := v.Aux
11174 mem := v.Args[1]
11175 v_0 := v.Args[0]
11176 if v_0.Op != Op386ADDLconst {
11177 break
11178 }
11179 off := v_0.AuxInt
11180 ptr := v_0.Args[0]
11181 if !(ValAndOff(sc).canAdd(off)) {
11182 break
11183 }
11184 v.reset(Op386MOVWstoreconst)
11185 v.AuxInt = ValAndOff(sc).add(off)
11186 v.Aux = s
11187 v.AddArg(ptr)
11188 v.AddArg(mem)
11189 return true
11190 }
11191
11192
11193
11194 for {
11195 sc := v.AuxInt
11196 sym1 := v.Aux
11197 mem := v.Args[1]
11198 v_0 := v.Args[0]
11199 if v_0.Op != Op386LEAL {
11200 break
11201 }
11202 off := v_0.AuxInt
11203 sym2 := v_0.Aux
11204 ptr := v_0.Args[0]
11205 if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)) {
11206 break
11207 }
11208 v.reset(Op386MOVWstoreconst)
11209 v.AuxInt = ValAndOff(sc).add(off)
11210 v.Aux = mergeSym(sym1, sym2)
11211 v.AddArg(ptr)
11212 v.AddArg(mem)
11213 return true
11214 }
11215
11216
11217
11218 for {
11219 x := v.AuxInt
11220 sym1 := v.Aux
11221 mem := v.Args[1]
11222 v_0 := v.Args[0]
11223 if v_0.Op != Op386LEAL1 {
11224 break
11225 }
11226 off := v_0.AuxInt
11227 sym2 := v_0.Aux
11228 idx := v_0.Args[1]
11229 ptr := v_0.Args[0]
11230 if !(canMergeSym(sym1, sym2)) {
11231 break
11232 }
11233 v.reset(Op386MOVWstoreconstidx1)
11234 v.AuxInt = ValAndOff(x).add(off)
11235 v.Aux = mergeSym(sym1, sym2)
11236 v.AddArg(ptr)
11237 v.AddArg(idx)
11238 v.AddArg(mem)
11239 return true
11240 }
11241
11242
11243
11244 for {
11245 x := v.AuxInt
11246 sym1 := v.Aux
11247 mem := v.Args[1]
11248 v_0 := v.Args[0]
11249 if v_0.Op != Op386LEAL2 {
11250 break
11251 }
11252 off := v_0.AuxInt
11253 sym2 := v_0.Aux
11254 idx := v_0.Args[1]
11255 ptr := v_0.Args[0]
11256 if !(canMergeSym(sym1, sym2)) {
11257 break
11258 }
11259 v.reset(Op386MOVWstoreconstidx2)
11260 v.AuxInt = ValAndOff(x).add(off)
11261 v.Aux = mergeSym(sym1, sym2)
11262 v.AddArg(ptr)
11263 v.AddArg(idx)
11264 v.AddArg(mem)
11265 return true
11266 }
11267
11268
11269
11270 for {
11271 x := v.AuxInt
11272 sym := v.Aux
11273 mem := v.Args[1]
11274 v_0 := v.Args[0]
11275 if v_0.Op != Op386ADDL {
11276 break
11277 }
11278 idx := v_0.Args[1]
11279 ptr := v_0.Args[0]
11280 v.reset(Op386MOVWstoreconstidx1)
11281 v.AuxInt = x
11282 v.Aux = sym
11283 v.AddArg(ptr)
11284 v.AddArg(idx)
11285 v.AddArg(mem)
11286 return true
11287 }
11288
11289
11290
11291 for {
11292 c := v.AuxInt
11293 s := v.Aux
11294 _ = v.Args[1]
11295 p := v.Args[0]
11296 x := v.Args[1]
11297 if x.Op != Op386MOVWstoreconst {
11298 break
11299 }
11300 a := x.AuxInt
11301 if x.Aux != s {
11302 break
11303 }
11304 mem := x.Args[1]
11305 if p != x.Args[0] {
11306 break
11307 }
11308 if !(x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) {
11309 break
11310 }
11311 v.reset(Op386MOVLstoreconst)
11312 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xffff|ValAndOff(c).Val()<<16, ValAndOff(a).Off())
11313 v.Aux = s
11314 v.AddArg(p)
11315 v.AddArg(mem)
11316 return true
11317 }
11318
11319
11320
11321 for {
11322 a := v.AuxInt
11323 s := v.Aux
11324 _ = v.Args[1]
11325 p := v.Args[0]
11326 x := v.Args[1]
11327 if x.Op != Op386MOVWstoreconst {
11328 break
11329 }
11330 c := x.AuxInt
11331 if x.Aux != s {
11332 break
11333 }
11334 mem := x.Args[1]
11335 if p != x.Args[0] {
11336 break
11337 }
11338 if !(x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) {
11339 break
11340 }
11341 v.reset(Op386MOVLstoreconst)
11342 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xffff|ValAndOff(c).Val()<<16, ValAndOff(a).Off())
11343 v.Aux = s
11344 v.AddArg(p)
11345 v.AddArg(mem)
11346 return true
11347 }
11348 return false
11349 }
11350 func rewriteValue386_Op386MOVWstoreconstidx1_0(v *Value) bool {
11351
11352
11353
11354 for {
11355 c := v.AuxInt
11356 sym := v.Aux
11357 mem := v.Args[2]
11358 ptr := v.Args[0]
11359 v_1 := v.Args[1]
11360 if v_1.Op != Op386SHLLconst {
11361 break
11362 }
11363 if v_1.AuxInt != 1 {
11364 break
11365 }
11366 idx := v_1.Args[0]
11367 v.reset(Op386MOVWstoreconstidx2)
11368 v.AuxInt = c
11369 v.Aux = sym
11370 v.AddArg(ptr)
11371 v.AddArg(idx)
11372 v.AddArg(mem)
11373 return true
11374 }
11375
11376
11377
11378 for {
11379 x := v.AuxInt
11380 sym := v.Aux
11381 mem := v.Args[2]
11382 v_0 := v.Args[0]
11383 if v_0.Op != Op386ADDLconst {
11384 break
11385 }
11386 c := v_0.AuxInt
11387 ptr := v_0.Args[0]
11388 idx := v.Args[1]
11389 v.reset(Op386MOVWstoreconstidx1)
11390 v.AuxInt = ValAndOff(x).add(c)
11391 v.Aux = sym
11392 v.AddArg(ptr)
11393 v.AddArg(idx)
11394 v.AddArg(mem)
11395 return true
11396 }
11397
11398
11399
11400 for {
11401 x := v.AuxInt
11402 sym := v.Aux
11403 mem := v.Args[2]
11404 ptr := v.Args[0]
11405 v_1 := v.Args[1]
11406 if v_1.Op != Op386ADDLconst {
11407 break
11408 }
11409 c := v_1.AuxInt
11410 idx := v_1.Args[0]
11411 v.reset(Op386MOVWstoreconstidx1)
11412 v.AuxInt = ValAndOff(x).add(c)
11413 v.Aux = sym
11414 v.AddArg(ptr)
11415 v.AddArg(idx)
11416 v.AddArg(mem)
11417 return true
11418 }
11419
11420
11421
11422 for {
11423 c := v.AuxInt
11424 s := v.Aux
11425 _ = v.Args[2]
11426 p := v.Args[0]
11427 i := v.Args[1]
11428 x := v.Args[2]
11429 if x.Op != Op386MOVWstoreconstidx1 {
11430 break
11431 }
11432 a := x.AuxInt
11433 if x.Aux != s {
11434 break
11435 }
11436 mem := x.Args[2]
11437 if p != x.Args[0] {
11438 break
11439 }
11440 if i != x.Args[1] {
11441 break
11442 }
11443 if !(x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) {
11444 break
11445 }
11446 v.reset(Op386MOVLstoreconstidx1)
11447 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xffff|ValAndOff(c).Val()<<16, ValAndOff(a).Off())
11448 v.Aux = s
11449 v.AddArg(p)
11450 v.AddArg(i)
11451 v.AddArg(mem)
11452 return true
11453 }
11454 return false
11455 }
11456 func rewriteValue386_Op386MOVWstoreconstidx2_0(v *Value) bool {
11457 b := v.Block
11458
11459
11460
11461 for {
11462 x := v.AuxInt
11463 sym := v.Aux
11464 mem := v.Args[2]
11465 v_0 := v.Args[0]
11466 if v_0.Op != Op386ADDLconst {
11467 break
11468 }
11469 c := v_0.AuxInt
11470 ptr := v_0.Args[0]
11471 idx := v.Args[1]
11472 v.reset(Op386MOVWstoreconstidx2)
11473 v.AuxInt = ValAndOff(x).add(c)
11474 v.Aux = sym
11475 v.AddArg(ptr)
11476 v.AddArg(idx)
11477 v.AddArg(mem)
11478 return true
11479 }
11480
11481
11482
11483 for {
11484 x := v.AuxInt
11485 sym := v.Aux
11486 mem := v.Args[2]
11487 ptr := v.Args[0]
11488 v_1 := v.Args[1]
11489 if v_1.Op != Op386ADDLconst {
11490 break
11491 }
11492 c := v_1.AuxInt
11493 idx := v_1.Args[0]
11494 v.reset(Op386MOVWstoreconstidx2)
11495 v.AuxInt = ValAndOff(x).add(2 * c)
11496 v.Aux = sym
11497 v.AddArg(ptr)
11498 v.AddArg(idx)
11499 v.AddArg(mem)
11500 return true
11501 }
11502
11503
11504
11505 for {
11506 c := v.AuxInt
11507 s := v.Aux
11508 _ = v.Args[2]
11509 p := v.Args[0]
11510 i := v.Args[1]
11511 x := v.Args[2]
11512 if x.Op != Op386MOVWstoreconstidx2 {
11513 break
11514 }
11515 a := x.AuxInt
11516 if x.Aux != s {
11517 break
11518 }
11519 mem := x.Args[2]
11520 if p != x.Args[0] {
11521 break
11522 }
11523 if i != x.Args[1] {
11524 break
11525 }
11526 if !(x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) {
11527 break
11528 }
11529 v.reset(Op386MOVLstoreconstidx1)
11530 v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xffff|ValAndOff(c).Val()<<16, ValAndOff(a).Off())
11531 v.Aux = s
11532 v.AddArg(p)
11533 v0 := b.NewValue0(v.Pos, Op386SHLLconst, i.Type)
11534 v0.AuxInt = 1
11535 v0.AddArg(i)
11536 v.AddArg(v0)
11537 v.AddArg(mem)
11538 return true
11539 }
11540 return false
11541 }
11542 func rewriteValue386_Op386MOVWstoreidx1_0(v *Value) bool {
11543
11544
11545
11546 for {
11547 c := v.AuxInt
11548 sym := v.Aux
11549 mem := v.Args[3]
11550 ptr := v.Args[0]
11551 v_1 := v.Args[1]
11552 if v_1.Op != Op386SHLLconst {
11553 break
11554 }
11555 if v_1.AuxInt != 1 {
11556 break
11557 }
11558 idx := v_1.Args[0]
11559 val := v.Args[2]
11560 v.reset(Op386MOVWstoreidx2)
11561 v.AuxInt = c
11562 v.Aux = sym
11563 v.AddArg(ptr)
11564 v.AddArg(idx)
11565 v.AddArg(val)
11566 v.AddArg(mem)
11567 return true
11568 }
11569
11570
11571
11572 for {
11573 c := v.AuxInt
11574 sym := v.Aux
11575 mem := v.Args[3]
11576 v_0 := v.Args[0]
11577 if v_0.Op != Op386SHLLconst {
11578 break
11579 }
11580 if v_0.AuxInt != 1 {
11581 break
11582 }
11583 idx := v_0.Args[0]
11584 ptr := v.Args[1]
11585 val := v.Args[2]
11586 v.reset(Op386MOVWstoreidx2)
11587 v.AuxInt = c
11588 v.Aux = sym
11589 v.AddArg(ptr)
11590 v.AddArg(idx)
11591 v.AddArg(val)
11592 v.AddArg(mem)
11593 return true
11594 }
11595
11596
11597
11598 for {
11599 c := v.AuxInt
11600 sym := v.Aux
11601 mem := v.Args[3]
11602 v_0 := v.Args[0]
11603 if v_0.Op != Op386ADDLconst {
11604 break
11605 }
11606 d := v_0.AuxInt
11607 ptr := v_0.Args[0]
11608 idx := v.Args[1]
11609 val := v.Args[2]
11610 v.reset(Op386MOVWstoreidx1)
11611 v.AuxInt = int64(int32(c + d))
11612 v.Aux = sym
11613 v.AddArg(ptr)
11614 v.AddArg(idx)
11615 v.AddArg(val)
11616 v.AddArg(mem)
11617 return true
11618 }
11619
11620
11621
11622 for {
11623 c := v.AuxInt
11624 sym := v.Aux
11625 mem := v.Args[3]
11626 idx := v.Args[0]
11627 v_1 := v.Args[1]
11628 if v_1.Op != Op386ADDLconst {
11629 break
11630 }
11631 d := v_1.AuxInt
11632 ptr := v_1.Args[0]
11633 val := v.Args[2]
11634 v.reset(Op386MOVWstoreidx1)
11635 v.AuxInt = int64(int32(c + d))
11636 v.Aux = sym
11637 v.AddArg(ptr)
11638 v.AddArg(idx)
11639 v.AddArg(val)
11640 v.AddArg(mem)
11641 return true
11642 }
11643
11644
11645
11646 for {
11647 c := v.AuxInt
11648 sym := v.Aux
11649 mem := v.Args[3]
11650 ptr := v.Args[0]
11651 v_1 := v.Args[1]
11652 if v_1.Op != Op386ADDLconst {
11653 break
11654 }
11655 d := v_1.AuxInt
11656 idx := v_1.Args[0]
11657 val := v.Args[2]
11658 v.reset(Op386MOVWstoreidx1)
11659 v.AuxInt = int64(int32(c + d))
11660 v.Aux = sym
11661 v.AddArg(ptr)
11662 v.AddArg(idx)
11663 v.AddArg(val)
11664 v.AddArg(mem)
11665 return true
11666 }
11667
11668
11669
11670 for {
11671 c := v.AuxInt
11672 sym := v.Aux
11673 mem := v.Args[3]
11674 v_0 := v.Args[0]
11675 if v_0.Op != Op386ADDLconst {
11676 break
11677 }
11678 d := v_0.AuxInt
11679 idx := v_0.Args[0]
11680 ptr := v.Args[1]
11681 val := v.Args[2]
11682 v.reset(Op386MOVWstoreidx1)
11683 v.AuxInt = int64(int32(c + d))
11684 v.Aux = sym
11685 v.AddArg(ptr)
11686 v.AddArg(idx)
11687 v.AddArg(val)
11688 v.AddArg(mem)
11689 return true
11690 }
11691
11692
11693
11694 for {
11695 i := v.AuxInt
11696 s := v.Aux
11697 _ = v.Args[3]
11698 p := v.Args[0]
11699 idx := v.Args[1]
11700 v_2 := v.Args[2]
11701 if v_2.Op != Op386SHRLconst {
11702 break
11703 }
11704 if v_2.AuxInt != 16 {
11705 break
11706 }
11707 w := v_2.Args[0]
11708 x := v.Args[3]
11709 if x.Op != Op386MOVWstoreidx1 {
11710 break
11711 }
11712 if x.AuxInt != i-2 {
11713 break
11714 }
11715 if x.Aux != s {
11716 break
11717 }
11718 mem := x.Args[3]
11719 if p != x.Args[0] {
11720 break
11721 }
11722 if idx != x.Args[1] {
11723 break
11724 }
11725 if w != x.Args[2] {
11726 break
11727 }
11728 if !(x.Uses == 1 && clobber(x)) {
11729 break
11730 }
11731 v.reset(Op386MOVLstoreidx1)
11732 v.AuxInt = i - 2
11733 v.Aux = s
11734 v.AddArg(p)
11735 v.AddArg(idx)
11736 v.AddArg(w)
11737 v.AddArg(mem)
11738 return true
11739 }
11740
11741
11742
11743 for {
11744 i := v.AuxInt
11745 s := v.Aux
11746 _ = v.Args[3]
11747 p := v.Args[0]
11748 idx := v.Args[1]
11749 v_2 := v.Args[2]
11750 if v_2.Op != Op386SHRLconst {
11751 break
11752 }
11753 if v_2.AuxInt != 16 {
11754 break
11755 }
11756 w := v_2.Args[0]
11757 x := v.Args[3]
11758 if x.Op != Op386MOVWstoreidx1 {
11759 break
11760 }
11761 if x.AuxInt != i-2 {
11762 break
11763 }
11764 if x.Aux != s {
11765 break
11766 }
11767 mem := x.Args[3]
11768 if idx != x.Args[0] {
11769 break
11770 }
11771 if p != x.Args[1] {
11772 break
11773 }
11774 if w != x.Args[2] {
11775 break
11776 }
11777 if !(x.Uses == 1 && clobber(x)) {
11778 break
11779 }
11780 v.reset(Op386MOVLstoreidx1)
11781 v.AuxInt = i - 2
11782 v.Aux = s
11783 v.AddArg(p)
11784 v.AddArg(idx)
11785 v.AddArg(w)
11786 v.AddArg(mem)
11787 return true
11788 }
11789
11790
11791
11792 for {
11793 i := v.AuxInt
11794 s := v.Aux
11795 _ = v.Args[3]
11796 idx := v.Args[0]
11797 p := v.Args[1]
11798 v_2 := v.Args[2]
11799 if v_2.Op != Op386SHRLconst {
11800 break
11801 }
11802 if v_2.AuxInt != 16 {
11803 break
11804 }
11805 w := v_2.Args[0]
11806 x := v.Args[3]
11807 if x.Op != Op386MOVWstoreidx1 {
11808 break
11809 }
11810 if x.AuxInt != i-2 {
11811 break
11812 }
11813 if x.Aux != s {
11814 break
11815 }
11816 mem := x.Args[3]
11817 if p != x.Args[0] {
11818 break
11819 }
11820 if idx != x.Args[1] {
11821 break
11822 }
11823 if w != x.Args[2] {
11824 break
11825 }
11826 if !(x.Uses == 1 && clobber(x)) {
11827 break
11828 }
11829 v.reset(Op386MOVLstoreidx1)
11830 v.AuxInt = i - 2
11831 v.Aux = s
11832 v.AddArg(p)
11833 v.AddArg(idx)
11834 v.AddArg(w)
11835 v.AddArg(mem)
11836 return true
11837 }
11838
11839
11840
11841 for {
11842 i := v.AuxInt
11843 s := v.Aux
11844 _ = v.Args[3]
11845 idx := v.Args[0]
11846 p := v.Args[1]
11847 v_2 := v.Args[2]
11848 if v_2.Op != Op386SHRLconst {
11849 break
11850 }
11851 if v_2.AuxInt != 16 {
11852 break
11853 }
11854 w := v_2.Args[0]
11855 x := v.Args[3]
11856 if x.Op != Op386MOVWstoreidx1 {
11857 break
11858 }
11859 if x.AuxInt != i-2 {
11860 break
11861 }
11862 if x.Aux != s {
11863 break
11864 }
11865 mem := x.Args[3]
11866 if idx != x.Args[0] {
11867 break
11868 }
11869 if p != x.Args[1] {
11870 break
11871 }
11872 if w != x.Args[2] {
11873 break
11874 }
11875 if !(x.Uses == 1 && clobber(x)) {
11876 break
11877 }
11878 v.reset(Op386MOVLstoreidx1)
11879 v.AuxInt = i - 2
11880 v.Aux = s
11881 v.AddArg(p)
11882 v.AddArg(idx)
11883 v.AddArg(w)
11884 v.AddArg(mem)
11885 return true
11886 }
11887 return false
11888 }
11889 func rewriteValue386_Op386MOVWstoreidx1_10(v *Value) bool {
11890
11891
11892
11893 for {
11894 i := v.AuxInt
11895 s := v.Aux
11896 _ = v.Args[3]
11897 p := v.Args[0]
11898 idx := v.Args[1]
11899 v_2 := v.Args[2]
11900 if v_2.Op != Op386SHRLconst {
11901 break
11902 }
11903 j := v_2.AuxInt
11904 w := v_2.Args[0]
11905 x := v.Args[3]
11906 if x.Op != Op386MOVWstoreidx1 {
11907 break
11908 }
11909 if x.AuxInt != i-2 {
11910 break
11911 }
11912 if x.Aux != s {
11913 break
11914 }
11915 mem := x.Args[3]
11916 if p != x.Args[0] {
11917 break
11918 }
11919 if idx != x.Args[1] {
11920 break
11921 }
11922 w0 := x.Args[2]
11923 if w0.Op != Op386SHRLconst {
11924 break
11925 }
11926 if w0.AuxInt != j-16 {
11927 break
11928 }
11929 if w != w0.Args[0] {
11930 break
11931 }
11932 if !(x.Uses == 1 && clobber(x)) {
11933 break
11934 }
11935 v.reset(Op386MOVLstoreidx1)
11936 v.AuxInt = i - 2
11937 v.Aux = s
11938 v.AddArg(p)
11939 v.AddArg(idx)
11940 v.AddArg(w0)
11941 v.AddArg(mem)
11942 return true
11943 }
11944
11945
11946
11947 for {
11948 i := v.AuxInt
11949 s := v.Aux
11950 _ = v.Args[3]
11951 p := v.Args[0]
11952 idx := v.Args[1]
11953 v_2 := v.Args[2]
11954 if v_2.Op != Op386SHRLconst {
11955 break
11956 }
11957 j := v_2.AuxInt
11958 w := v_2.Args[0]
11959 x := v.Args[3]
11960 if x.Op != Op386MOVWstoreidx1 {
11961 break
11962 }
11963 if x.AuxInt != i-2 {
11964 break
11965 }
11966 if x.Aux != s {
11967 break
11968 }
11969 mem := x.Args[3]
11970 if idx != x.Args[0] {
11971 break
11972 }
11973 if p != x.Args[1] {
11974 break
11975 }
11976 w0 := x.Args[2]
11977 if w0.Op != Op386SHRLconst {
11978 break
11979 }
11980 if w0.AuxInt != j-16 {
11981 break
11982 }
11983 if w != w0.Args[0] {
11984 break
11985 }
11986 if !(x.Uses == 1 && clobber(x)) {
11987 break
11988 }
11989 v.reset(Op386MOVLstoreidx1)
11990 v.AuxInt = i - 2
11991 v.Aux = s
11992 v.AddArg(p)
11993 v.AddArg(idx)
11994 v.AddArg(w0)
11995 v.AddArg(mem)
11996 return true
11997 }
11998
11999
12000
12001 for {
12002 i := v.AuxInt
12003 s := v.Aux
12004 _ = v.Args[3]
12005 idx := v.Args[0]
12006 p := v.Args[1]
12007 v_2 := v.Args[2]
12008 if v_2.Op != Op386SHRLconst {
12009 break
12010 }
12011 j := v_2.AuxInt
12012 w := v_2.Args[0]
12013 x := v.Args[3]
12014 if x.Op != Op386MOVWstoreidx1 {
12015 break
12016 }
12017 if x.AuxInt != i-2 {
12018 break
12019 }
12020 if x.Aux != s {
12021 break
12022 }
12023 mem := x.Args[3]
12024 if p != x.Args[0] {
12025 break
12026 }
12027 if idx != x.Args[1] {
12028 break
12029 }
12030 w0 := x.Args[2]
12031 if w0.Op != Op386SHRLconst {
12032 break
12033 }
12034 if w0.AuxInt != j-16 {
12035 break
12036 }
12037 if w != w0.Args[0] {
12038 break
12039 }
12040 if !(x.Uses == 1 && clobber(x)) {
12041 break
12042 }
12043 v.reset(Op386MOVLstoreidx1)
12044 v.AuxInt = i - 2
12045 v.Aux = s
12046 v.AddArg(p)
12047 v.AddArg(idx)
12048 v.AddArg(w0)
12049 v.AddArg(mem)
12050 return true
12051 }
12052
12053
12054
12055 for {
12056 i := v.AuxInt
12057 s := v.Aux
12058 _ = v.Args[3]
12059 idx := v.Args[0]
12060 p := v.Args[1]
12061 v_2 := v.Args[2]
12062 if v_2.Op != Op386SHRLconst {
12063 break
12064 }
12065 j := v_2.AuxInt
12066 w := v_2.Args[0]
12067 x := v.Args[3]
12068 if x.Op != Op386MOVWstoreidx1 {
12069 break
12070 }
12071 if x.AuxInt != i-2 {
12072 break
12073 }
12074 if x.Aux != s {
12075 break
12076 }
12077 mem := x.Args[3]
12078 if idx != x.Args[0] {
12079 break
12080 }
12081 if p != x.Args[1] {
12082 break
12083 }
12084 w0 := x.Args[2]
12085 if w0.Op != Op386SHRLconst {
12086 break
12087 }
12088 if w0.AuxInt != j-16 {
12089 break
12090 }
12091 if w != w0.Args[0] {
12092 break
12093 }
12094 if !(x.Uses == 1 && clobber(x)) {
12095 break
12096 }
12097 v.reset(Op386MOVLstoreidx1)
12098 v.AuxInt = i - 2
12099 v.Aux = s
12100 v.AddArg(p)
12101 v.AddArg(idx)
12102 v.AddArg(w0)
12103 v.AddArg(mem)
12104 return true
12105 }
12106 return false
12107 }
12108 func rewriteValue386_Op386MOVWstoreidx2_0(v *Value) bool {
12109 b := v.Block
12110
12111
12112
12113 for {
12114 c := v.AuxInt
12115 sym := v.Aux
12116 mem := v.Args[3]
12117 v_0 := v.Args[0]
12118 if v_0.Op != Op386ADDLconst {
12119 break
12120 }
12121 d := v_0.AuxInt
12122 ptr := v_0.Args[0]
12123 idx := v.Args[1]
12124 val := v.Args[2]
12125 v.reset(Op386MOVWstoreidx2)
12126 v.AuxInt = int64(int32(c + d))
12127 v.Aux = sym
12128 v.AddArg(ptr)
12129 v.AddArg(idx)
12130 v.AddArg(val)
12131 v.AddArg(mem)
12132 return true
12133 }
12134
12135
12136
12137 for {
12138 c := v.AuxInt
12139 sym := v.Aux
12140 mem := v.Args[3]
12141 ptr := v.Args[0]
12142 v_1 := v.Args[1]
12143 if v_1.Op != Op386ADDLconst {
12144 break
12145 }
12146 d := v_1.AuxInt
12147 idx := v_1.Args[0]
12148 val := v.Args[2]
12149 v.reset(Op386MOVWstoreidx2)
12150 v.AuxInt = int64(int32(c + 2*d))
12151 v.Aux = sym
12152 v.AddArg(ptr)
12153 v.AddArg(idx)
12154 v.AddArg(val)
12155 v.AddArg(mem)
12156 return true
12157 }
12158
12159
12160
12161 for {
12162 i := v.AuxInt
12163 s := v.Aux
12164 _ = v.Args[3]
12165 p := v.Args[0]
12166 idx := v.Args[1]
12167 v_2 := v.Args[2]
12168 if v_2.Op != Op386SHRLconst {
12169 break
12170 }
12171 if v_2.AuxInt != 16 {
12172 break
12173 }
12174 w := v_2.Args[0]
12175 x := v.Args[3]
12176 if x.Op != Op386MOVWstoreidx2 {
12177 break
12178 }
12179 if x.AuxInt != i-2 {
12180 break
12181 }
12182 if x.Aux != s {
12183 break
12184 }
12185 mem := x.Args[3]
12186 if p != x.Args[0] {
12187 break
12188 }
12189 if idx != x.Args[1] {
12190 break
12191 }
12192 if w != x.Args[2] {
12193 break
12194 }
12195 if !(x.Uses == 1 && clobber(x)) {
12196 break
12197 }
12198 v.reset(Op386MOVLstoreidx1)
12199 v.AuxInt = i - 2
12200 v.Aux = s
12201 v.AddArg(p)
12202 v0 := b.NewValue0(v.Pos, Op386SHLLconst, idx.Type)
12203 v0.AuxInt = 1
12204 v0.AddArg(idx)
12205 v.AddArg(v0)
12206 v.AddArg(w)
12207 v.AddArg(mem)
12208 return true
12209 }
12210
12211
12212
12213 for {
12214 i := v.AuxInt
12215 s := v.Aux
12216 _ = v.Args[3]
12217 p := v.Args[0]
12218 idx := v.Args[1]
12219 v_2 := v.Args[2]
12220 if v_2.Op != Op386SHRLconst {
12221 break
12222 }
12223 j := v_2.AuxInt
12224 w := v_2.Args[0]
12225 x := v.Args[3]
12226 if x.Op != Op386MOVWstoreidx2 {
12227 break
12228 }
12229 if x.AuxInt != i-2 {
12230 break
12231 }
12232 if x.Aux != s {
12233 break
12234 }
12235 mem := x.Args[3]
12236 if p != x.Args[0] {
12237 break
12238 }
12239 if idx != x.Args[1] {
12240 break
12241 }
12242 w0 := x.Args[2]
12243 if w0.Op != Op386SHRLconst {
12244 break
12245 }
12246 if w0.AuxInt != j-16 {
12247 break
12248 }
12249 if w != w0.Args[0] {
12250 break
12251 }
12252 if !(x.Uses == 1 && clobber(x)) {
12253 break
12254 }
12255 v.reset(Op386MOVLstoreidx1)
12256 v.AuxInt = i - 2
12257 v.Aux = s
12258 v.AddArg(p)
12259 v0 := b.NewValue0(v.Pos, Op386SHLLconst, idx.Type)
12260 v0.AuxInt = 1
12261 v0.AddArg(idx)
12262 v.AddArg(v0)
12263 v.AddArg(w0)
12264 v.AddArg(mem)
12265 return true
12266 }
12267 return false
12268 }
12269 func rewriteValue386_Op386MULL_0(v *Value) bool {
12270
12271
12272
12273 for {
12274 _ = v.Args[1]
12275 x := v.Args[0]
12276 v_1 := v.Args[1]
12277 if v_1.Op != Op386MOVLconst {
12278 break
12279 }
12280 c := v_1.AuxInt
12281 v.reset(Op386MULLconst)
12282 v.AuxInt = c
12283 v.AddArg(x)
12284 return true
12285 }
12286
12287
12288
12289 for {
12290 x := v.Args[1]
12291 v_0 := v.Args[0]
12292 if v_0.Op != Op386MOVLconst {
12293 break
12294 }
12295 c := v_0.AuxInt
12296 v.reset(Op386MULLconst)
12297 v.AuxInt = c
12298 v.AddArg(x)
12299 return true
12300 }
12301
12302
12303
12304 for {
12305 _ = v.Args[1]
12306 x := v.Args[0]
12307 l := v.Args[1]
12308 if l.Op != Op386MOVLload {
12309 break
12310 }
12311 off := l.AuxInt
12312 sym := l.Aux
12313 mem := l.Args[1]
12314 ptr := l.Args[0]
12315 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
12316 break
12317 }
12318 v.reset(Op386MULLload)
12319 v.AuxInt = off
12320 v.Aux = sym
12321 v.AddArg(x)
12322 v.AddArg(ptr)
12323 v.AddArg(mem)
12324 return true
12325 }
12326
12327
12328
12329 for {
12330 x := v.Args[1]
12331 l := v.Args[0]
12332 if l.Op != Op386MOVLload {
12333 break
12334 }
12335 off := l.AuxInt
12336 sym := l.Aux
12337 mem := l.Args[1]
12338 ptr := l.Args[0]
12339 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
12340 break
12341 }
12342 v.reset(Op386MULLload)
12343 v.AuxInt = off
12344 v.Aux = sym
12345 v.AddArg(x)
12346 v.AddArg(ptr)
12347 v.AddArg(mem)
12348 return true
12349 }
12350
12351
12352
12353 for {
12354 _ = v.Args[1]
12355 x := v.Args[0]
12356 l := v.Args[1]
12357 if l.Op != Op386MOVLloadidx4 {
12358 break
12359 }
12360 off := l.AuxInt
12361 sym := l.Aux
12362 mem := l.Args[2]
12363 ptr := l.Args[0]
12364 idx := l.Args[1]
12365 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
12366 break
12367 }
12368 v.reset(Op386MULLloadidx4)
12369 v.AuxInt = off
12370 v.Aux = sym
12371 v.AddArg(x)
12372 v.AddArg(ptr)
12373 v.AddArg(idx)
12374 v.AddArg(mem)
12375 return true
12376 }
12377
12378
12379
12380 for {
12381 x := v.Args[1]
12382 l := v.Args[0]
12383 if l.Op != Op386MOVLloadidx4 {
12384 break
12385 }
12386 off := l.AuxInt
12387 sym := l.Aux
12388 mem := l.Args[2]
12389 ptr := l.Args[0]
12390 idx := l.Args[1]
12391 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
12392 break
12393 }
12394 v.reset(Op386MULLloadidx4)
12395 v.AuxInt = off
12396 v.Aux = sym
12397 v.AddArg(x)
12398 v.AddArg(ptr)
12399 v.AddArg(idx)
12400 v.AddArg(mem)
12401 return true
12402 }
12403 return false
12404 }
12405 func rewriteValue386_Op386MULLconst_0(v *Value) bool {
12406 b := v.Block
12407
12408
12409
12410 for {
12411 c := v.AuxInt
12412 v_0 := v.Args[0]
12413 if v_0.Op != Op386MULLconst {
12414 break
12415 }
12416 d := v_0.AuxInt
12417 x := v_0.Args[0]
12418 v.reset(Op386MULLconst)
12419 v.AuxInt = int64(int32(c * d))
12420 v.AddArg(x)
12421 return true
12422 }
12423
12424
12425
12426 for {
12427 if v.AuxInt != -9 {
12428 break
12429 }
12430 x := v.Args[0]
12431 v.reset(Op386NEGL)
12432 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type)
12433 v0.AddArg(x)
12434 v0.AddArg(x)
12435 v.AddArg(v0)
12436 return true
12437 }
12438
12439
12440
12441 for {
12442 if v.AuxInt != -5 {
12443 break
12444 }
12445 x := v.Args[0]
12446 v.reset(Op386NEGL)
12447 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type)
12448 v0.AddArg(x)
12449 v0.AddArg(x)
12450 v.AddArg(v0)
12451 return true
12452 }
12453
12454
12455
12456 for {
12457 if v.AuxInt != -3 {
12458 break
12459 }
12460 x := v.Args[0]
12461 v.reset(Op386NEGL)
12462 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type)
12463 v0.AddArg(x)
12464 v0.AddArg(x)
12465 v.AddArg(v0)
12466 return true
12467 }
12468
12469
12470
12471 for {
12472 if v.AuxInt != -1 {
12473 break
12474 }
12475 x := v.Args[0]
12476 v.reset(Op386NEGL)
12477 v.AddArg(x)
12478 return true
12479 }
12480
12481
12482
12483 for {
12484 if v.AuxInt != 0 {
12485 break
12486 }
12487 v.reset(Op386MOVLconst)
12488 v.AuxInt = 0
12489 return true
12490 }
12491
12492
12493
12494 for {
12495 if v.AuxInt != 1 {
12496 break
12497 }
12498 x := v.Args[0]
12499 v.reset(OpCopy)
12500 v.Type = x.Type
12501 v.AddArg(x)
12502 return true
12503 }
12504
12505
12506
12507 for {
12508 if v.AuxInt != 3 {
12509 break
12510 }
12511 x := v.Args[0]
12512 v.reset(Op386LEAL2)
12513 v.AddArg(x)
12514 v.AddArg(x)
12515 return true
12516 }
12517
12518
12519
12520 for {
12521 if v.AuxInt != 5 {
12522 break
12523 }
12524 x := v.Args[0]
12525 v.reset(Op386LEAL4)
12526 v.AddArg(x)
12527 v.AddArg(x)
12528 return true
12529 }
12530
12531
12532
12533 for {
12534 if v.AuxInt != 7 {
12535 break
12536 }
12537 x := v.Args[0]
12538 v.reset(Op386LEAL2)
12539 v.AddArg(x)
12540 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type)
12541 v0.AddArg(x)
12542 v0.AddArg(x)
12543 v.AddArg(v0)
12544 return true
12545 }
12546 return false
12547 }
12548 func rewriteValue386_Op386MULLconst_10(v *Value) bool {
12549 b := v.Block
12550
12551
12552
12553 for {
12554 if v.AuxInt != 9 {
12555 break
12556 }
12557 x := v.Args[0]
12558 v.reset(Op386LEAL8)
12559 v.AddArg(x)
12560 v.AddArg(x)
12561 return true
12562 }
12563
12564
12565
12566 for {
12567 if v.AuxInt != 11 {
12568 break
12569 }
12570 x := v.Args[0]
12571 v.reset(Op386LEAL2)
12572 v.AddArg(x)
12573 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type)
12574 v0.AddArg(x)
12575 v0.AddArg(x)
12576 v.AddArg(v0)
12577 return true
12578 }
12579
12580
12581
12582 for {
12583 if v.AuxInt != 13 {
12584 break
12585 }
12586 x := v.Args[0]
12587 v.reset(Op386LEAL4)
12588 v.AddArg(x)
12589 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type)
12590 v0.AddArg(x)
12591 v0.AddArg(x)
12592 v.AddArg(v0)
12593 return true
12594 }
12595
12596
12597
12598 for {
12599 if v.AuxInt != 19 {
12600 break
12601 }
12602 x := v.Args[0]
12603 v.reset(Op386LEAL2)
12604 v.AddArg(x)
12605 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type)
12606 v0.AddArg(x)
12607 v0.AddArg(x)
12608 v.AddArg(v0)
12609 return true
12610 }
12611
12612
12613
12614 for {
12615 if v.AuxInt != 21 {
12616 break
12617 }
12618 x := v.Args[0]
12619 v.reset(Op386LEAL4)
12620 v.AddArg(x)
12621 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type)
12622 v0.AddArg(x)
12623 v0.AddArg(x)
12624 v.AddArg(v0)
12625 return true
12626 }
12627
12628
12629
12630 for {
12631 if v.AuxInt != 25 {
12632 break
12633 }
12634 x := v.Args[0]
12635 v.reset(Op386LEAL8)
12636 v.AddArg(x)
12637 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type)
12638 v0.AddArg(x)
12639 v0.AddArg(x)
12640 v.AddArg(v0)
12641 return true
12642 }
12643
12644
12645
12646 for {
12647 if v.AuxInt != 27 {
12648 break
12649 }
12650 x := v.Args[0]
12651 v.reset(Op386LEAL8)
12652 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type)
12653 v0.AddArg(x)
12654 v0.AddArg(x)
12655 v.AddArg(v0)
12656 v1 := b.NewValue0(v.Pos, Op386LEAL2, v.Type)
12657 v1.AddArg(x)
12658 v1.AddArg(x)
12659 v.AddArg(v1)
12660 return true
12661 }
12662
12663
12664
12665 for {
12666 if v.AuxInt != 37 {
12667 break
12668 }
12669 x := v.Args[0]
12670 v.reset(Op386LEAL4)
12671 v.AddArg(x)
12672 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type)
12673 v0.AddArg(x)
12674 v0.AddArg(x)
12675 v.AddArg(v0)
12676 return true
12677 }
12678
12679
12680
12681 for {
12682 if v.AuxInt != 41 {
12683 break
12684 }
12685 x := v.Args[0]
12686 v.reset(Op386LEAL8)
12687 v.AddArg(x)
12688 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type)
12689 v0.AddArg(x)
12690 v0.AddArg(x)
12691 v.AddArg(v0)
12692 return true
12693 }
12694
12695
12696
12697 for {
12698 if v.AuxInt != 45 {
12699 break
12700 }
12701 x := v.Args[0]
12702 v.reset(Op386LEAL8)
12703 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type)
12704 v0.AddArg(x)
12705 v0.AddArg(x)
12706 v.AddArg(v0)
12707 v1 := b.NewValue0(v.Pos, Op386LEAL4, v.Type)
12708 v1.AddArg(x)
12709 v1.AddArg(x)
12710 v.AddArg(v1)
12711 return true
12712 }
12713 return false
12714 }
12715 func rewriteValue386_Op386MULLconst_20(v *Value) bool {
12716 b := v.Block
12717
12718
12719
12720 for {
12721 if v.AuxInt != 73 {
12722 break
12723 }
12724 x := v.Args[0]
12725 v.reset(Op386LEAL8)
12726 v.AddArg(x)
12727 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type)
12728 v0.AddArg(x)
12729 v0.AddArg(x)
12730 v.AddArg(v0)
12731 return true
12732 }
12733
12734
12735
12736 for {
12737 if v.AuxInt != 81 {
12738 break
12739 }
12740 x := v.Args[0]
12741 v.reset(Op386LEAL8)
12742 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type)
12743 v0.AddArg(x)
12744 v0.AddArg(x)
12745 v.AddArg(v0)
12746 v1 := b.NewValue0(v.Pos, Op386LEAL8, v.Type)
12747 v1.AddArg(x)
12748 v1.AddArg(x)
12749 v.AddArg(v1)
12750 return true
12751 }
12752
12753
12754
12755 for {
12756 c := v.AuxInt
12757 x := v.Args[0]
12758 if !(isPowerOfTwo(c+1) && c >= 15) {
12759 break
12760 }
12761 v.reset(Op386SUBL)
12762 v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type)
12763 v0.AuxInt = log2(c + 1)
12764 v0.AddArg(x)
12765 v.AddArg(v0)
12766 v.AddArg(x)
12767 return true
12768 }
12769
12770
12771
12772 for {
12773 c := v.AuxInt
12774 x := v.Args[0]
12775 if !(isPowerOfTwo(c-1) && c >= 17) {
12776 break
12777 }
12778 v.reset(Op386LEAL1)
12779 v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type)
12780 v0.AuxInt = log2(c - 1)
12781 v0.AddArg(x)
12782 v.AddArg(v0)
12783 v.AddArg(x)
12784 return true
12785 }
12786
12787
12788
12789 for {
12790 c := v.AuxInt
12791 x := v.Args[0]
12792 if !(isPowerOfTwo(c-2) && c >= 34) {
12793 break
12794 }
12795 v.reset(Op386LEAL2)
12796 v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type)
12797 v0.AuxInt = log2(c - 2)
12798 v0.AddArg(x)
12799 v.AddArg(v0)
12800 v.AddArg(x)
12801 return true
12802 }
12803
12804
12805
12806 for {
12807 c := v.AuxInt
12808 x := v.Args[0]
12809 if !(isPowerOfTwo(c-4) && c >= 68) {
12810 break
12811 }
12812 v.reset(Op386LEAL4)
12813 v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type)
12814 v0.AuxInt = log2(c - 4)
12815 v0.AddArg(x)
12816 v.AddArg(v0)
12817 v.AddArg(x)
12818 return true
12819 }
12820
12821
12822
12823 for {
12824 c := v.AuxInt
12825 x := v.Args[0]
12826 if !(isPowerOfTwo(c-8) && c >= 136) {
12827 break
12828 }
12829 v.reset(Op386LEAL8)
12830 v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type)
12831 v0.AuxInt = log2(c - 8)
12832 v0.AddArg(x)
12833 v.AddArg(v0)
12834 v.AddArg(x)
12835 return true
12836 }
12837
12838
12839
12840 for {
12841 c := v.AuxInt
12842 x := v.Args[0]
12843 if !(c%3 == 0 && isPowerOfTwo(c/3)) {
12844 break
12845 }
12846 v.reset(Op386SHLLconst)
12847 v.AuxInt = log2(c / 3)
12848 v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type)
12849 v0.AddArg(x)
12850 v0.AddArg(x)
12851 v.AddArg(v0)
12852 return true
12853 }
12854
12855
12856
12857 for {
12858 c := v.AuxInt
12859 x := v.Args[0]
12860 if !(c%5 == 0 && isPowerOfTwo(c/5)) {
12861 break
12862 }
12863 v.reset(Op386SHLLconst)
12864 v.AuxInt = log2(c / 5)
12865 v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type)
12866 v0.AddArg(x)
12867 v0.AddArg(x)
12868 v.AddArg(v0)
12869 return true
12870 }
12871
12872
12873
12874 for {
12875 c := v.AuxInt
12876 x := v.Args[0]
12877 if !(c%9 == 0 && isPowerOfTwo(c/9)) {
12878 break
12879 }
12880 v.reset(Op386SHLLconst)
12881 v.AuxInt = log2(c / 9)
12882 v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type)
12883 v0.AddArg(x)
12884 v0.AddArg(x)
12885 v.AddArg(v0)
12886 return true
12887 }
12888 return false
12889 }
12890 func rewriteValue386_Op386MULLconst_30(v *Value) bool {
12891
12892
12893
12894 for {
12895 c := v.AuxInt
12896 v_0 := v.Args[0]
12897 if v_0.Op != Op386MOVLconst {
12898 break
12899 }
12900 d := v_0.AuxInt
12901 v.reset(Op386MOVLconst)
12902 v.AuxInt = int64(int32(c * d))
12903 return true
12904 }
12905 return false
12906 }
12907 func rewriteValue386_Op386MULLload_0(v *Value) bool {
12908 b := v.Block
12909 config := b.Func.Config
12910
12911
12912
12913 for {
12914 off1 := v.AuxInt
12915 sym := v.Aux
12916 mem := v.Args[2]
12917 val := v.Args[0]
12918 v_1 := v.Args[1]
12919 if v_1.Op != Op386ADDLconst {
12920 break
12921 }
12922 off2 := v_1.AuxInt
12923 base := v_1.Args[0]
12924 if !(is32Bit(off1 + off2)) {
12925 break
12926 }
12927 v.reset(Op386MULLload)
12928 v.AuxInt = off1 + off2
12929 v.Aux = sym
12930 v.AddArg(val)
12931 v.AddArg(base)
12932 v.AddArg(mem)
12933 return true
12934 }
12935
12936
12937
12938 for {
12939 off1 := v.AuxInt
12940 sym1 := v.Aux
12941 mem := v.Args[2]
12942 val := v.Args[0]
12943 v_1 := v.Args[1]
12944 if v_1.Op != Op386LEAL {
12945 break
12946 }
12947 off2 := v_1.AuxInt
12948 sym2 := v_1.Aux
12949 base := v_1.Args[0]
12950 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
12951 break
12952 }
12953 v.reset(Op386MULLload)
12954 v.AuxInt = off1 + off2
12955 v.Aux = mergeSym(sym1, sym2)
12956 v.AddArg(val)
12957 v.AddArg(base)
12958 v.AddArg(mem)
12959 return true
12960 }
12961
12962
12963
12964 for {
12965 off1 := v.AuxInt
12966 sym1 := v.Aux
12967 mem := v.Args[2]
12968 val := v.Args[0]
12969 v_1 := v.Args[1]
12970 if v_1.Op != Op386LEAL4 {
12971 break
12972 }
12973 off2 := v_1.AuxInt
12974 sym2 := v_1.Aux
12975 idx := v_1.Args[1]
12976 ptr := v_1.Args[0]
12977 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
12978 break
12979 }
12980 v.reset(Op386MULLloadidx4)
12981 v.AuxInt = off1 + off2
12982 v.Aux = mergeSym(sym1, sym2)
12983 v.AddArg(val)
12984 v.AddArg(ptr)
12985 v.AddArg(idx)
12986 v.AddArg(mem)
12987 return true
12988 }
12989 return false
12990 }
12991 func rewriteValue386_Op386MULLloadidx4_0(v *Value) bool {
12992 b := v.Block
12993 config := b.Func.Config
12994
12995
12996
12997 for {
12998 off1 := v.AuxInt
12999 sym := v.Aux
13000 mem := v.Args[3]
13001 val := v.Args[0]
13002 v_1 := v.Args[1]
13003 if v_1.Op != Op386ADDLconst {
13004 break
13005 }
13006 off2 := v_1.AuxInt
13007 base := v_1.Args[0]
13008 idx := v.Args[2]
13009 if !(is32Bit(off1 + off2)) {
13010 break
13011 }
13012 v.reset(Op386MULLloadidx4)
13013 v.AuxInt = off1 + off2
13014 v.Aux = sym
13015 v.AddArg(val)
13016 v.AddArg(base)
13017 v.AddArg(idx)
13018 v.AddArg(mem)
13019 return true
13020 }
13021
13022
13023
13024 for {
13025 off1 := v.AuxInt
13026 sym := v.Aux
13027 mem := v.Args[3]
13028 val := v.Args[0]
13029 base := v.Args[1]
13030 v_2 := v.Args[2]
13031 if v_2.Op != Op386ADDLconst {
13032 break
13033 }
13034 off2 := v_2.AuxInt
13035 idx := v_2.Args[0]
13036 if !(is32Bit(off1 + off2*4)) {
13037 break
13038 }
13039 v.reset(Op386MULLloadidx4)
13040 v.AuxInt = off1 + off2*4
13041 v.Aux = sym
13042 v.AddArg(val)
13043 v.AddArg(base)
13044 v.AddArg(idx)
13045 v.AddArg(mem)
13046 return true
13047 }
13048
13049
13050
13051 for {
13052 off1 := v.AuxInt
13053 sym1 := v.Aux
13054 mem := v.Args[3]
13055 val := v.Args[0]
13056 v_1 := v.Args[1]
13057 if v_1.Op != Op386LEAL {
13058 break
13059 }
13060 off2 := v_1.AuxInt
13061 sym2 := v_1.Aux
13062 base := v_1.Args[0]
13063 idx := v.Args[2]
13064 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
13065 break
13066 }
13067 v.reset(Op386MULLloadidx4)
13068 v.AuxInt = off1 + off2
13069 v.Aux = mergeSym(sym1, sym2)
13070 v.AddArg(val)
13071 v.AddArg(base)
13072 v.AddArg(idx)
13073 v.AddArg(mem)
13074 return true
13075 }
13076 return false
13077 }
13078 func rewriteValue386_Op386MULSD_0(v *Value) bool {
13079 b := v.Block
13080 config := b.Func.Config
13081
13082
13083
13084 for {
13085 _ = v.Args[1]
13086 x := v.Args[0]
13087 l := v.Args[1]
13088 if l.Op != Op386MOVSDload {
13089 break
13090 }
13091 off := l.AuxInt
13092 sym := l.Aux
13093 mem := l.Args[1]
13094 ptr := l.Args[0]
13095 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
13096 break
13097 }
13098 v.reset(Op386MULSDload)
13099 v.AuxInt = off
13100 v.Aux = sym
13101 v.AddArg(x)
13102 v.AddArg(ptr)
13103 v.AddArg(mem)
13104 return true
13105 }
13106
13107
13108
13109 for {
13110 x := v.Args[1]
13111 l := v.Args[0]
13112 if l.Op != Op386MOVSDload {
13113 break
13114 }
13115 off := l.AuxInt
13116 sym := l.Aux
13117 mem := l.Args[1]
13118 ptr := l.Args[0]
13119 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
13120 break
13121 }
13122 v.reset(Op386MULSDload)
13123 v.AuxInt = off
13124 v.Aux = sym
13125 v.AddArg(x)
13126 v.AddArg(ptr)
13127 v.AddArg(mem)
13128 return true
13129 }
13130 return false
13131 }
13132 func rewriteValue386_Op386MULSDload_0(v *Value) bool {
13133 b := v.Block
13134 config := b.Func.Config
13135
13136
13137
13138 for {
13139 off1 := v.AuxInt
13140 sym := v.Aux
13141 mem := v.Args[2]
13142 val := v.Args[0]
13143 v_1 := v.Args[1]
13144 if v_1.Op != Op386ADDLconst {
13145 break
13146 }
13147 off2 := v_1.AuxInt
13148 base := v_1.Args[0]
13149 if !(is32Bit(off1 + off2)) {
13150 break
13151 }
13152 v.reset(Op386MULSDload)
13153 v.AuxInt = off1 + off2
13154 v.Aux = sym
13155 v.AddArg(val)
13156 v.AddArg(base)
13157 v.AddArg(mem)
13158 return true
13159 }
13160
13161
13162
13163 for {
13164 off1 := v.AuxInt
13165 sym1 := v.Aux
13166 mem := v.Args[2]
13167 val := v.Args[0]
13168 v_1 := v.Args[1]
13169 if v_1.Op != Op386LEAL {
13170 break
13171 }
13172 off2 := v_1.AuxInt
13173 sym2 := v_1.Aux
13174 base := v_1.Args[0]
13175 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
13176 break
13177 }
13178 v.reset(Op386MULSDload)
13179 v.AuxInt = off1 + off2
13180 v.Aux = mergeSym(sym1, sym2)
13181 v.AddArg(val)
13182 v.AddArg(base)
13183 v.AddArg(mem)
13184 return true
13185 }
13186 return false
13187 }
13188 func rewriteValue386_Op386MULSS_0(v *Value) bool {
13189 b := v.Block
13190 config := b.Func.Config
13191
13192
13193
13194 for {
13195 _ = v.Args[1]
13196 x := v.Args[0]
13197 l := v.Args[1]
13198 if l.Op != Op386MOVSSload {
13199 break
13200 }
13201 off := l.AuxInt
13202 sym := l.Aux
13203 mem := l.Args[1]
13204 ptr := l.Args[0]
13205 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
13206 break
13207 }
13208 v.reset(Op386MULSSload)
13209 v.AuxInt = off
13210 v.Aux = sym
13211 v.AddArg(x)
13212 v.AddArg(ptr)
13213 v.AddArg(mem)
13214 return true
13215 }
13216
13217
13218
13219 for {
13220 x := v.Args[1]
13221 l := v.Args[0]
13222 if l.Op != Op386MOVSSload {
13223 break
13224 }
13225 off := l.AuxInt
13226 sym := l.Aux
13227 mem := l.Args[1]
13228 ptr := l.Args[0]
13229 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
13230 break
13231 }
13232 v.reset(Op386MULSSload)
13233 v.AuxInt = off
13234 v.Aux = sym
13235 v.AddArg(x)
13236 v.AddArg(ptr)
13237 v.AddArg(mem)
13238 return true
13239 }
13240 return false
13241 }
13242 func rewriteValue386_Op386MULSSload_0(v *Value) bool {
13243 b := v.Block
13244 config := b.Func.Config
13245
13246
13247
13248 for {
13249 off1 := v.AuxInt
13250 sym := v.Aux
13251 mem := v.Args[2]
13252 val := v.Args[0]
13253 v_1 := v.Args[1]
13254 if v_1.Op != Op386ADDLconst {
13255 break
13256 }
13257 off2 := v_1.AuxInt
13258 base := v_1.Args[0]
13259 if !(is32Bit(off1 + off2)) {
13260 break
13261 }
13262 v.reset(Op386MULSSload)
13263 v.AuxInt = off1 + off2
13264 v.Aux = sym
13265 v.AddArg(val)
13266 v.AddArg(base)
13267 v.AddArg(mem)
13268 return true
13269 }
13270
13271
13272
13273 for {
13274 off1 := v.AuxInt
13275 sym1 := v.Aux
13276 mem := v.Args[2]
13277 val := v.Args[0]
13278 v_1 := v.Args[1]
13279 if v_1.Op != Op386LEAL {
13280 break
13281 }
13282 off2 := v_1.AuxInt
13283 sym2 := v_1.Aux
13284 base := v_1.Args[0]
13285 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
13286 break
13287 }
13288 v.reset(Op386MULSSload)
13289 v.AuxInt = off1 + off2
13290 v.Aux = mergeSym(sym1, sym2)
13291 v.AddArg(val)
13292 v.AddArg(base)
13293 v.AddArg(mem)
13294 return true
13295 }
13296 return false
13297 }
13298 func rewriteValue386_Op386NEGL_0(v *Value) bool {
13299
13300
13301
13302 for {
13303 v_0 := v.Args[0]
13304 if v_0.Op != Op386MOVLconst {
13305 break
13306 }
13307 c := v_0.AuxInt
13308 v.reset(Op386MOVLconst)
13309 v.AuxInt = int64(int32(-c))
13310 return true
13311 }
13312 return false
13313 }
13314 func rewriteValue386_Op386NOTL_0(v *Value) bool {
13315
13316
13317
13318 for {
13319 v_0 := v.Args[0]
13320 if v_0.Op != Op386MOVLconst {
13321 break
13322 }
13323 c := v_0.AuxInt
13324 v.reset(Op386MOVLconst)
13325 v.AuxInt = ^c
13326 return true
13327 }
13328 return false
13329 }
13330 func rewriteValue386_Op386ORL_0(v *Value) bool {
13331
13332
13333
13334 for {
13335 _ = v.Args[1]
13336 x := v.Args[0]
13337 v_1 := v.Args[1]
13338 if v_1.Op != Op386MOVLconst {
13339 break
13340 }
13341 c := v_1.AuxInt
13342 v.reset(Op386ORLconst)
13343 v.AuxInt = c
13344 v.AddArg(x)
13345 return true
13346 }
13347
13348
13349
13350 for {
13351 x := v.Args[1]
13352 v_0 := v.Args[0]
13353 if v_0.Op != Op386MOVLconst {
13354 break
13355 }
13356 c := v_0.AuxInt
13357 v.reset(Op386ORLconst)
13358 v.AuxInt = c
13359 v.AddArg(x)
13360 return true
13361 }
13362
13363
13364
13365 for {
13366 _ = v.Args[1]
13367 v_0 := v.Args[0]
13368 if v_0.Op != Op386SHLLconst {
13369 break
13370 }
13371 c := v_0.AuxInt
13372 x := v_0.Args[0]
13373 v_1 := v.Args[1]
13374 if v_1.Op != Op386SHRLconst {
13375 break
13376 }
13377 d := v_1.AuxInt
13378 if x != v_1.Args[0] {
13379 break
13380 }
13381 if !(d == 32-c) {
13382 break
13383 }
13384 v.reset(Op386ROLLconst)
13385 v.AuxInt = c
13386 v.AddArg(x)
13387 return true
13388 }
13389
13390
13391
13392 for {
13393 _ = v.Args[1]
13394 v_0 := v.Args[0]
13395 if v_0.Op != Op386SHRLconst {
13396 break
13397 }
13398 d := v_0.AuxInt
13399 x := v_0.Args[0]
13400 v_1 := v.Args[1]
13401 if v_1.Op != Op386SHLLconst {
13402 break
13403 }
13404 c := v_1.AuxInt
13405 if x != v_1.Args[0] {
13406 break
13407 }
13408 if !(d == 32-c) {
13409 break
13410 }
13411 v.reset(Op386ROLLconst)
13412 v.AuxInt = c
13413 v.AddArg(x)
13414 return true
13415 }
13416
13417
13418
13419 for {
13420 t := v.Type
13421 _ = v.Args[1]
13422 v_0 := v.Args[0]
13423 if v_0.Op != Op386SHLLconst {
13424 break
13425 }
13426 c := v_0.AuxInt
13427 x := v_0.Args[0]
13428 v_1 := v.Args[1]
13429 if v_1.Op != Op386SHRWconst {
13430 break
13431 }
13432 d := v_1.AuxInt
13433 if x != v_1.Args[0] {
13434 break
13435 }
13436 if !(c < 16 && d == 16-c && t.Size() == 2) {
13437 break
13438 }
13439 v.reset(Op386ROLWconst)
13440 v.AuxInt = c
13441 v.AddArg(x)
13442 return true
13443 }
13444
13445
13446
13447 for {
13448 t := v.Type
13449 _ = v.Args[1]
13450 v_0 := v.Args[0]
13451 if v_0.Op != Op386SHRWconst {
13452 break
13453 }
13454 d := v_0.AuxInt
13455 x := v_0.Args[0]
13456 v_1 := v.Args[1]
13457 if v_1.Op != Op386SHLLconst {
13458 break
13459 }
13460 c := v_1.AuxInt
13461 if x != v_1.Args[0] {
13462 break
13463 }
13464 if !(c < 16 && d == 16-c && t.Size() == 2) {
13465 break
13466 }
13467 v.reset(Op386ROLWconst)
13468 v.AuxInt = c
13469 v.AddArg(x)
13470 return true
13471 }
13472
13473
13474
13475 for {
13476 t := v.Type
13477 _ = v.Args[1]
13478 v_0 := v.Args[0]
13479 if v_0.Op != Op386SHLLconst {
13480 break
13481 }
13482 c := v_0.AuxInt
13483 x := v_0.Args[0]
13484 v_1 := v.Args[1]
13485 if v_1.Op != Op386SHRBconst {
13486 break
13487 }
13488 d := v_1.AuxInt
13489 if x != v_1.Args[0] {
13490 break
13491 }
13492 if !(c < 8 && d == 8-c && t.Size() == 1) {
13493 break
13494 }
13495 v.reset(Op386ROLBconst)
13496 v.AuxInt = c
13497 v.AddArg(x)
13498 return true
13499 }
13500
13501
13502
13503 for {
13504 t := v.Type
13505 _ = v.Args[1]
13506 v_0 := v.Args[0]
13507 if v_0.Op != Op386SHRBconst {
13508 break
13509 }
13510 d := v_0.AuxInt
13511 x := v_0.Args[0]
13512 v_1 := v.Args[1]
13513 if v_1.Op != Op386SHLLconst {
13514 break
13515 }
13516 c := v_1.AuxInt
13517 if x != v_1.Args[0] {
13518 break
13519 }
13520 if !(c < 8 && d == 8-c && t.Size() == 1) {
13521 break
13522 }
13523 v.reset(Op386ROLBconst)
13524 v.AuxInt = c
13525 v.AddArg(x)
13526 return true
13527 }
13528
13529
13530
13531 for {
13532 _ = v.Args[1]
13533 x := v.Args[0]
13534 l := v.Args[1]
13535 if l.Op != Op386MOVLload {
13536 break
13537 }
13538 off := l.AuxInt
13539 sym := l.Aux
13540 mem := l.Args[1]
13541 ptr := l.Args[0]
13542 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
13543 break
13544 }
13545 v.reset(Op386ORLload)
13546 v.AuxInt = off
13547 v.Aux = sym
13548 v.AddArg(x)
13549 v.AddArg(ptr)
13550 v.AddArg(mem)
13551 return true
13552 }
13553
13554
13555
13556 for {
13557 x := v.Args[1]
13558 l := v.Args[0]
13559 if l.Op != Op386MOVLload {
13560 break
13561 }
13562 off := l.AuxInt
13563 sym := l.Aux
13564 mem := l.Args[1]
13565 ptr := l.Args[0]
13566 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
13567 break
13568 }
13569 v.reset(Op386ORLload)
13570 v.AuxInt = off
13571 v.Aux = sym
13572 v.AddArg(x)
13573 v.AddArg(ptr)
13574 v.AddArg(mem)
13575 return true
13576 }
13577 return false
13578 }
13579 func rewriteValue386_Op386ORL_10(v *Value) bool {
13580 b := v.Block
13581 typ := &b.Func.Config.Types
13582
13583
13584
13585 for {
13586 _ = v.Args[1]
13587 x := v.Args[0]
13588 l := v.Args[1]
13589 if l.Op != Op386MOVLloadidx4 {
13590 break
13591 }
13592 off := l.AuxInt
13593 sym := l.Aux
13594 mem := l.Args[2]
13595 ptr := l.Args[0]
13596 idx := l.Args[1]
13597 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
13598 break
13599 }
13600 v.reset(Op386ORLloadidx4)
13601 v.AuxInt = off
13602 v.Aux = sym
13603 v.AddArg(x)
13604 v.AddArg(ptr)
13605 v.AddArg(idx)
13606 v.AddArg(mem)
13607 return true
13608 }
13609
13610
13611
13612 for {
13613 x := v.Args[1]
13614 l := v.Args[0]
13615 if l.Op != Op386MOVLloadidx4 {
13616 break
13617 }
13618 off := l.AuxInt
13619 sym := l.Aux
13620 mem := l.Args[2]
13621 ptr := l.Args[0]
13622 idx := l.Args[1]
13623 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
13624 break
13625 }
13626 v.reset(Op386ORLloadidx4)
13627 v.AuxInt = off
13628 v.Aux = sym
13629 v.AddArg(x)
13630 v.AddArg(ptr)
13631 v.AddArg(idx)
13632 v.AddArg(mem)
13633 return true
13634 }
13635
13636
13637
13638 for {
13639 x := v.Args[1]
13640 if x != v.Args[0] {
13641 break
13642 }
13643 v.reset(OpCopy)
13644 v.Type = x.Type
13645 v.AddArg(x)
13646 return true
13647 }
13648
13649
13650
13651 for {
13652 _ = v.Args[1]
13653 x0 := v.Args[0]
13654 if x0.Op != Op386MOVBload {
13655 break
13656 }
13657 i0 := x0.AuxInt
13658 s := x0.Aux
13659 mem := x0.Args[1]
13660 p := x0.Args[0]
13661 s0 := v.Args[1]
13662 if s0.Op != Op386SHLLconst {
13663 break
13664 }
13665 if s0.AuxInt != 8 {
13666 break
13667 }
13668 x1 := s0.Args[0]
13669 if x1.Op != Op386MOVBload {
13670 break
13671 }
13672 i1 := x1.AuxInt
13673 if x1.Aux != s {
13674 break
13675 }
13676 _ = x1.Args[1]
13677 if p != x1.Args[0] {
13678 break
13679 }
13680 if mem != x1.Args[1] {
13681 break
13682 }
13683 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
13684 break
13685 }
13686 b = mergePoint(b, x0, x1)
13687 v0 := b.NewValue0(x1.Pos, Op386MOVWload, typ.UInt16)
13688 v.reset(OpCopy)
13689 v.AddArg(v0)
13690 v0.AuxInt = i0
13691 v0.Aux = s
13692 v0.AddArg(p)
13693 v0.AddArg(mem)
13694 return true
13695 }
13696
13697
13698
13699 for {
13700 _ = v.Args[1]
13701 s0 := v.Args[0]
13702 if s0.Op != Op386SHLLconst {
13703 break
13704 }
13705 if s0.AuxInt != 8 {
13706 break
13707 }
13708 x1 := s0.Args[0]
13709 if x1.Op != Op386MOVBload {
13710 break
13711 }
13712 i1 := x1.AuxInt
13713 s := x1.Aux
13714 mem := x1.Args[1]
13715 p := x1.Args[0]
13716 x0 := v.Args[1]
13717 if x0.Op != Op386MOVBload {
13718 break
13719 }
13720 i0 := x0.AuxInt
13721 if x0.Aux != s {
13722 break
13723 }
13724 _ = x0.Args[1]
13725 if p != x0.Args[0] {
13726 break
13727 }
13728 if mem != x0.Args[1] {
13729 break
13730 }
13731 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
13732 break
13733 }
13734 b = mergePoint(b, x0, x1)
13735 v0 := b.NewValue0(x0.Pos, Op386MOVWload, typ.UInt16)
13736 v.reset(OpCopy)
13737 v.AddArg(v0)
13738 v0.AuxInt = i0
13739 v0.Aux = s
13740 v0.AddArg(p)
13741 v0.AddArg(mem)
13742 return true
13743 }
13744
13745
13746
13747 for {
13748 _ = v.Args[1]
13749 o0 := v.Args[0]
13750 if o0.Op != Op386ORL {
13751 break
13752 }
13753 _ = o0.Args[1]
13754 x0 := o0.Args[0]
13755 if x0.Op != Op386MOVWload {
13756 break
13757 }
13758 i0 := x0.AuxInt
13759 s := x0.Aux
13760 mem := x0.Args[1]
13761 p := x0.Args[0]
13762 s0 := o0.Args[1]
13763 if s0.Op != Op386SHLLconst {
13764 break
13765 }
13766 if s0.AuxInt != 16 {
13767 break
13768 }
13769 x1 := s0.Args[0]
13770 if x1.Op != Op386MOVBload {
13771 break
13772 }
13773 i2 := x1.AuxInt
13774 if x1.Aux != s {
13775 break
13776 }
13777 _ = x1.Args[1]
13778 if p != x1.Args[0] {
13779 break
13780 }
13781 if mem != x1.Args[1] {
13782 break
13783 }
13784 s1 := v.Args[1]
13785 if s1.Op != Op386SHLLconst {
13786 break
13787 }
13788 if s1.AuxInt != 24 {
13789 break
13790 }
13791 x2 := s1.Args[0]
13792 if x2.Op != Op386MOVBload {
13793 break
13794 }
13795 i3 := x2.AuxInt
13796 if x2.Aux != s {
13797 break
13798 }
13799 _ = x2.Args[1]
13800 if p != x2.Args[0] {
13801 break
13802 }
13803 if mem != x2.Args[1] {
13804 break
13805 }
13806 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
13807 break
13808 }
13809 b = mergePoint(b, x0, x1, x2)
13810 v0 := b.NewValue0(x2.Pos, Op386MOVLload, typ.UInt32)
13811 v.reset(OpCopy)
13812 v.AddArg(v0)
13813 v0.AuxInt = i0
13814 v0.Aux = s
13815 v0.AddArg(p)
13816 v0.AddArg(mem)
13817 return true
13818 }
13819
13820
13821
13822 for {
13823 _ = v.Args[1]
13824 o0 := v.Args[0]
13825 if o0.Op != Op386ORL {
13826 break
13827 }
13828 _ = o0.Args[1]
13829 s0 := o0.Args[0]
13830 if s0.Op != Op386SHLLconst {
13831 break
13832 }
13833 if s0.AuxInt != 16 {
13834 break
13835 }
13836 x1 := s0.Args[0]
13837 if x1.Op != Op386MOVBload {
13838 break
13839 }
13840 i2 := x1.AuxInt
13841 s := x1.Aux
13842 mem := x1.Args[1]
13843 p := x1.Args[0]
13844 x0 := o0.Args[1]
13845 if x0.Op != Op386MOVWload {
13846 break
13847 }
13848 i0 := x0.AuxInt
13849 if x0.Aux != s {
13850 break
13851 }
13852 _ = x0.Args[1]
13853 if p != x0.Args[0] {
13854 break
13855 }
13856 if mem != x0.Args[1] {
13857 break
13858 }
13859 s1 := v.Args[1]
13860 if s1.Op != Op386SHLLconst {
13861 break
13862 }
13863 if s1.AuxInt != 24 {
13864 break
13865 }
13866 x2 := s1.Args[0]
13867 if x2.Op != Op386MOVBload {
13868 break
13869 }
13870 i3 := x2.AuxInt
13871 if x2.Aux != s {
13872 break
13873 }
13874 _ = x2.Args[1]
13875 if p != x2.Args[0] {
13876 break
13877 }
13878 if mem != x2.Args[1] {
13879 break
13880 }
13881 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
13882 break
13883 }
13884 b = mergePoint(b, x0, x1, x2)
13885 v0 := b.NewValue0(x2.Pos, Op386MOVLload, typ.UInt32)
13886 v.reset(OpCopy)
13887 v.AddArg(v0)
13888 v0.AuxInt = i0
13889 v0.Aux = s
13890 v0.AddArg(p)
13891 v0.AddArg(mem)
13892 return true
13893 }
13894
13895
13896
13897 for {
13898 _ = v.Args[1]
13899 s1 := v.Args[0]
13900 if s1.Op != Op386SHLLconst {
13901 break
13902 }
13903 if s1.AuxInt != 24 {
13904 break
13905 }
13906 x2 := s1.Args[0]
13907 if x2.Op != Op386MOVBload {
13908 break
13909 }
13910 i3 := x2.AuxInt
13911 s := x2.Aux
13912 mem := x2.Args[1]
13913 p := x2.Args[0]
13914 o0 := v.Args[1]
13915 if o0.Op != Op386ORL {
13916 break
13917 }
13918 _ = o0.Args[1]
13919 x0 := o0.Args[0]
13920 if x0.Op != Op386MOVWload {
13921 break
13922 }
13923 i0 := x0.AuxInt
13924 if x0.Aux != s {
13925 break
13926 }
13927 _ = x0.Args[1]
13928 if p != x0.Args[0] {
13929 break
13930 }
13931 if mem != x0.Args[1] {
13932 break
13933 }
13934 s0 := o0.Args[1]
13935 if s0.Op != Op386SHLLconst {
13936 break
13937 }
13938 if s0.AuxInt != 16 {
13939 break
13940 }
13941 x1 := s0.Args[0]
13942 if x1.Op != Op386MOVBload {
13943 break
13944 }
13945 i2 := x1.AuxInt
13946 if x1.Aux != s {
13947 break
13948 }
13949 _ = x1.Args[1]
13950 if p != x1.Args[0] {
13951 break
13952 }
13953 if mem != x1.Args[1] {
13954 break
13955 }
13956 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
13957 break
13958 }
13959 b = mergePoint(b, x0, x1, x2)
13960 v0 := b.NewValue0(x1.Pos, Op386MOVLload, typ.UInt32)
13961 v.reset(OpCopy)
13962 v.AddArg(v0)
13963 v0.AuxInt = i0
13964 v0.Aux = s
13965 v0.AddArg(p)
13966 v0.AddArg(mem)
13967 return true
13968 }
13969
13970
13971
13972 for {
13973 _ = v.Args[1]
13974 s1 := v.Args[0]
13975 if s1.Op != Op386SHLLconst {
13976 break
13977 }
13978 if s1.AuxInt != 24 {
13979 break
13980 }
13981 x2 := s1.Args[0]
13982 if x2.Op != Op386MOVBload {
13983 break
13984 }
13985 i3 := x2.AuxInt
13986 s := x2.Aux
13987 mem := x2.Args[1]
13988 p := x2.Args[0]
13989 o0 := v.Args[1]
13990 if o0.Op != Op386ORL {
13991 break
13992 }
13993 _ = o0.Args[1]
13994 s0 := o0.Args[0]
13995 if s0.Op != Op386SHLLconst {
13996 break
13997 }
13998 if s0.AuxInt != 16 {
13999 break
14000 }
14001 x1 := s0.Args[0]
14002 if x1.Op != Op386MOVBload {
14003 break
14004 }
14005 i2 := x1.AuxInt
14006 if x1.Aux != s {
14007 break
14008 }
14009 _ = x1.Args[1]
14010 if p != x1.Args[0] {
14011 break
14012 }
14013 if mem != x1.Args[1] {
14014 break
14015 }
14016 x0 := o0.Args[1]
14017 if x0.Op != Op386MOVWload {
14018 break
14019 }
14020 i0 := x0.AuxInt
14021 if x0.Aux != s {
14022 break
14023 }
14024 _ = x0.Args[1]
14025 if p != x0.Args[0] {
14026 break
14027 }
14028 if mem != x0.Args[1] {
14029 break
14030 }
14031 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
14032 break
14033 }
14034 b = mergePoint(b, x0, x1, x2)
14035 v0 := b.NewValue0(x0.Pos, Op386MOVLload, typ.UInt32)
14036 v.reset(OpCopy)
14037 v.AddArg(v0)
14038 v0.AuxInt = i0
14039 v0.Aux = s
14040 v0.AddArg(p)
14041 v0.AddArg(mem)
14042 return true
14043 }
14044
14045
14046
14047 for {
14048 _ = v.Args[1]
14049 x0 := v.Args[0]
14050 if x0.Op != Op386MOVBloadidx1 {
14051 break
14052 }
14053 i0 := x0.AuxInt
14054 s := x0.Aux
14055 mem := x0.Args[2]
14056 p := x0.Args[0]
14057 idx := x0.Args[1]
14058 s0 := v.Args[1]
14059 if s0.Op != Op386SHLLconst {
14060 break
14061 }
14062 if s0.AuxInt != 8 {
14063 break
14064 }
14065 x1 := s0.Args[0]
14066 if x1.Op != Op386MOVBloadidx1 {
14067 break
14068 }
14069 i1 := x1.AuxInt
14070 if x1.Aux != s {
14071 break
14072 }
14073 _ = x1.Args[2]
14074 if p != x1.Args[0] {
14075 break
14076 }
14077 if idx != x1.Args[1] {
14078 break
14079 }
14080 if mem != x1.Args[2] {
14081 break
14082 }
14083 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
14084 break
14085 }
14086 b = mergePoint(b, x0, x1)
14087 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
14088 v.reset(OpCopy)
14089 v.AddArg(v0)
14090 v0.AuxInt = i0
14091 v0.Aux = s
14092 v0.AddArg(p)
14093 v0.AddArg(idx)
14094 v0.AddArg(mem)
14095 return true
14096 }
14097 return false
14098 }
14099 func rewriteValue386_Op386ORL_20(v *Value) bool {
14100 b := v.Block
14101
14102
14103
14104 for {
14105 _ = v.Args[1]
14106 x0 := v.Args[0]
14107 if x0.Op != Op386MOVBloadidx1 {
14108 break
14109 }
14110 i0 := x0.AuxInt
14111 s := x0.Aux
14112 mem := x0.Args[2]
14113 idx := x0.Args[0]
14114 p := x0.Args[1]
14115 s0 := v.Args[1]
14116 if s0.Op != Op386SHLLconst {
14117 break
14118 }
14119 if s0.AuxInt != 8 {
14120 break
14121 }
14122 x1 := s0.Args[0]
14123 if x1.Op != Op386MOVBloadidx1 {
14124 break
14125 }
14126 i1 := x1.AuxInt
14127 if x1.Aux != s {
14128 break
14129 }
14130 _ = x1.Args[2]
14131 if p != x1.Args[0] {
14132 break
14133 }
14134 if idx != x1.Args[1] {
14135 break
14136 }
14137 if mem != x1.Args[2] {
14138 break
14139 }
14140 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
14141 break
14142 }
14143 b = mergePoint(b, x0, x1)
14144 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
14145 v.reset(OpCopy)
14146 v.AddArg(v0)
14147 v0.AuxInt = i0
14148 v0.Aux = s
14149 v0.AddArg(p)
14150 v0.AddArg(idx)
14151 v0.AddArg(mem)
14152 return true
14153 }
14154
14155
14156
14157 for {
14158 _ = v.Args[1]
14159 x0 := v.Args[0]
14160 if x0.Op != Op386MOVBloadidx1 {
14161 break
14162 }
14163 i0 := x0.AuxInt
14164 s := x0.Aux
14165 mem := x0.Args[2]
14166 p := x0.Args[0]
14167 idx := x0.Args[1]
14168 s0 := v.Args[1]
14169 if s0.Op != Op386SHLLconst {
14170 break
14171 }
14172 if s0.AuxInt != 8 {
14173 break
14174 }
14175 x1 := s0.Args[0]
14176 if x1.Op != Op386MOVBloadidx1 {
14177 break
14178 }
14179 i1 := x1.AuxInt
14180 if x1.Aux != s {
14181 break
14182 }
14183 _ = x1.Args[2]
14184 if idx != x1.Args[0] {
14185 break
14186 }
14187 if p != x1.Args[1] {
14188 break
14189 }
14190 if mem != x1.Args[2] {
14191 break
14192 }
14193 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
14194 break
14195 }
14196 b = mergePoint(b, x0, x1)
14197 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
14198 v.reset(OpCopy)
14199 v.AddArg(v0)
14200 v0.AuxInt = i0
14201 v0.Aux = s
14202 v0.AddArg(p)
14203 v0.AddArg(idx)
14204 v0.AddArg(mem)
14205 return true
14206 }
14207
14208
14209
14210 for {
14211 _ = v.Args[1]
14212 x0 := v.Args[0]
14213 if x0.Op != Op386MOVBloadidx1 {
14214 break
14215 }
14216 i0 := x0.AuxInt
14217 s := x0.Aux
14218 mem := x0.Args[2]
14219 idx := x0.Args[0]
14220 p := x0.Args[1]
14221 s0 := v.Args[1]
14222 if s0.Op != Op386SHLLconst {
14223 break
14224 }
14225 if s0.AuxInt != 8 {
14226 break
14227 }
14228 x1 := s0.Args[0]
14229 if x1.Op != Op386MOVBloadidx1 {
14230 break
14231 }
14232 i1 := x1.AuxInt
14233 if x1.Aux != s {
14234 break
14235 }
14236 _ = x1.Args[2]
14237 if idx != x1.Args[0] {
14238 break
14239 }
14240 if p != x1.Args[1] {
14241 break
14242 }
14243 if mem != x1.Args[2] {
14244 break
14245 }
14246 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
14247 break
14248 }
14249 b = mergePoint(b, x0, x1)
14250 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
14251 v.reset(OpCopy)
14252 v.AddArg(v0)
14253 v0.AuxInt = i0
14254 v0.Aux = s
14255 v0.AddArg(p)
14256 v0.AddArg(idx)
14257 v0.AddArg(mem)
14258 return true
14259 }
14260
14261
14262
14263 for {
14264 _ = v.Args[1]
14265 s0 := v.Args[0]
14266 if s0.Op != Op386SHLLconst {
14267 break
14268 }
14269 if s0.AuxInt != 8 {
14270 break
14271 }
14272 x1 := s0.Args[0]
14273 if x1.Op != Op386MOVBloadidx1 {
14274 break
14275 }
14276 i1 := x1.AuxInt
14277 s := x1.Aux
14278 mem := x1.Args[2]
14279 p := x1.Args[0]
14280 idx := x1.Args[1]
14281 x0 := v.Args[1]
14282 if x0.Op != Op386MOVBloadidx1 {
14283 break
14284 }
14285 i0 := x0.AuxInt
14286 if x0.Aux != s {
14287 break
14288 }
14289 _ = x0.Args[2]
14290 if p != x0.Args[0] {
14291 break
14292 }
14293 if idx != x0.Args[1] {
14294 break
14295 }
14296 if mem != x0.Args[2] {
14297 break
14298 }
14299 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
14300 break
14301 }
14302 b = mergePoint(b, x0, x1)
14303 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
14304 v.reset(OpCopy)
14305 v.AddArg(v0)
14306 v0.AuxInt = i0
14307 v0.Aux = s
14308 v0.AddArg(p)
14309 v0.AddArg(idx)
14310 v0.AddArg(mem)
14311 return true
14312 }
14313
14314
14315
14316 for {
14317 _ = v.Args[1]
14318 s0 := v.Args[0]
14319 if s0.Op != Op386SHLLconst {
14320 break
14321 }
14322 if s0.AuxInt != 8 {
14323 break
14324 }
14325 x1 := s0.Args[0]
14326 if x1.Op != Op386MOVBloadidx1 {
14327 break
14328 }
14329 i1 := x1.AuxInt
14330 s := x1.Aux
14331 mem := x1.Args[2]
14332 idx := x1.Args[0]
14333 p := x1.Args[1]
14334 x0 := v.Args[1]
14335 if x0.Op != Op386MOVBloadidx1 {
14336 break
14337 }
14338 i0 := x0.AuxInt
14339 if x0.Aux != s {
14340 break
14341 }
14342 _ = x0.Args[2]
14343 if p != x0.Args[0] {
14344 break
14345 }
14346 if idx != x0.Args[1] {
14347 break
14348 }
14349 if mem != x0.Args[2] {
14350 break
14351 }
14352 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
14353 break
14354 }
14355 b = mergePoint(b, x0, x1)
14356 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
14357 v.reset(OpCopy)
14358 v.AddArg(v0)
14359 v0.AuxInt = i0
14360 v0.Aux = s
14361 v0.AddArg(p)
14362 v0.AddArg(idx)
14363 v0.AddArg(mem)
14364 return true
14365 }
14366
14367
14368
14369 for {
14370 _ = v.Args[1]
14371 s0 := v.Args[0]
14372 if s0.Op != Op386SHLLconst {
14373 break
14374 }
14375 if s0.AuxInt != 8 {
14376 break
14377 }
14378 x1 := s0.Args[0]
14379 if x1.Op != Op386MOVBloadidx1 {
14380 break
14381 }
14382 i1 := x1.AuxInt
14383 s := x1.Aux
14384 mem := x1.Args[2]
14385 p := x1.Args[0]
14386 idx := x1.Args[1]
14387 x0 := v.Args[1]
14388 if x0.Op != Op386MOVBloadidx1 {
14389 break
14390 }
14391 i0 := x0.AuxInt
14392 if x0.Aux != s {
14393 break
14394 }
14395 _ = x0.Args[2]
14396 if idx != x0.Args[0] {
14397 break
14398 }
14399 if p != x0.Args[1] {
14400 break
14401 }
14402 if mem != x0.Args[2] {
14403 break
14404 }
14405 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
14406 break
14407 }
14408 b = mergePoint(b, x0, x1)
14409 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
14410 v.reset(OpCopy)
14411 v.AddArg(v0)
14412 v0.AuxInt = i0
14413 v0.Aux = s
14414 v0.AddArg(p)
14415 v0.AddArg(idx)
14416 v0.AddArg(mem)
14417 return true
14418 }
14419
14420
14421
14422 for {
14423 _ = v.Args[1]
14424 s0 := v.Args[0]
14425 if s0.Op != Op386SHLLconst {
14426 break
14427 }
14428 if s0.AuxInt != 8 {
14429 break
14430 }
14431 x1 := s0.Args[0]
14432 if x1.Op != Op386MOVBloadidx1 {
14433 break
14434 }
14435 i1 := x1.AuxInt
14436 s := x1.Aux
14437 mem := x1.Args[2]
14438 idx := x1.Args[0]
14439 p := x1.Args[1]
14440 x0 := v.Args[1]
14441 if x0.Op != Op386MOVBloadidx1 {
14442 break
14443 }
14444 i0 := x0.AuxInt
14445 if x0.Aux != s {
14446 break
14447 }
14448 _ = x0.Args[2]
14449 if idx != x0.Args[0] {
14450 break
14451 }
14452 if p != x0.Args[1] {
14453 break
14454 }
14455 if mem != x0.Args[2] {
14456 break
14457 }
14458 if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
14459 break
14460 }
14461 b = mergePoint(b, x0, x1)
14462 v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
14463 v.reset(OpCopy)
14464 v.AddArg(v0)
14465 v0.AuxInt = i0
14466 v0.Aux = s
14467 v0.AddArg(p)
14468 v0.AddArg(idx)
14469 v0.AddArg(mem)
14470 return true
14471 }
14472
14473
14474
14475 for {
14476 _ = v.Args[1]
14477 o0 := v.Args[0]
14478 if o0.Op != Op386ORL {
14479 break
14480 }
14481 _ = o0.Args[1]
14482 x0 := o0.Args[0]
14483 if x0.Op != Op386MOVWloadidx1 {
14484 break
14485 }
14486 i0 := x0.AuxInt
14487 s := x0.Aux
14488 mem := x0.Args[2]
14489 p := x0.Args[0]
14490 idx := x0.Args[1]
14491 s0 := o0.Args[1]
14492 if s0.Op != Op386SHLLconst {
14493 break
14494 }
14495 if s0.AuxInt != 16 {
14496 break
14497 }
14498 x1 := s0.Args[0]
14499 if x1.Op != Op386MOVBloadidx1 {
14500 break
14501 }
14502 i2 := x1.AuxInt
14503 if x1.Aux != s {
14504 break
14505 }
14506 _ = x1.Args[2]
14507 if p != x1.Args[0] {
14508 break
14509 }
14510 if idx != x1.Args[1] {
14511 break
14512 }
14513 if mem != x1.Args[2] {
14514 break
14515 }
14516 s1 := v.Args[1]
14517 if s1.Op != Op386SHLLconst {
14518 break
14519 }
14520 if s1.AuxInt != 24 {
14521 break
14522 }
14523 x2 := s1.Args[0]
14524 if x2.Op != Op386MOVBloadidx1 {
14525 break
14526 }
14527 i3 := x2.AuxInt
14528 if x2.Aux != s {
14529 break
14530 }
14531 _ = x2.Args[2]
14532 if p != x2.Args[0] {
14533 break
14534 }
14535 if idx != x2.Args[1] {
14536 break
14537 }
14538 if mem != x2.Args[2] {
14539 break
14540 }
14541 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
14542 break
14543 }
14544 b = mergePoint(b, x0, x1, x2)
14545 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
14546 v.reset(OpCopy)
14547 v.AddArg(v0)
14548 v0.AuxInt = i0
14549 v0.Aux = s
14550 v0.AddArg(p)
14551 v0.AddArg(idx)
14552 v0.AddArg(mem)
14553 return true
14554 }
14555
14556
14557
14558 for {
14559 _ = v.Args[1]
14560 o0 := v.Args[0]
14561 if o0.Op != Op386ORL {
14562 break
14563 }
14564 _ = o0.Args[1]
14565 x0 := o0.Args[0]
14566 if x0.Op != Op386MOVWloadidx1 {
14567 break
14568 }
14569 i0 := x0.AuxInt
14570 s := x0.Aux
14571 mem := x0.Args[2]
14572 idx := x0.Args[0]
14573 p := x0.Args[1]
14574 s0 := o0.Args[1]
14575 if s0.Op != Op386SHLLconst {
14576 break
14577 }
14578 if s0.AuxInt != 16 {
14579 break
14580 }
14581 x1 := s0.Args[0]
14582 if x1.Op != Op386MOVBloadidx1 {
14583 break
14584 }
14585 i2 := x1.AuxInt
14586 if x1.Aux != s {
14587 break
14588 }
14589 _ = x1.Args[2]
14590 if p != x1.Args[0] {
14591 break
14592 }
14593 if idx != x1.Args[1] {
14594 break
14595 }
14596 if mem != x1.Args[2] {
14597 break
14598 }
14599 s1 := v.Args[1]
14600 if s1.Op != Op386SHLLconst {
14601 break
14602 }
14603 if s1.AuxInt != 24 {
14604 break
14605 }
14606 x2 := s1.Args[0]
14607 if x2.Op != Op386MOVBloadidx1 {
14608 break
14609 }
14610 i3 := x2.AuxInt
14611 if x2.Aux != s {
14612 break
14613 }
14614 _ = x2.Args[2]
14615 if p != x2.Args[0] {
14616 break
14617 }
14618 if idx != x2.Args[1] {
14619 break
14620 }
14621 if mem != x2.Args[2] {
14622 break
14623 }
14624 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
14625 break
14626 }
14627 b = mergePoint(b, x0, x1, x2)
14628 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
14629 v.reset(OpCopy)
14630 v.AddArg(v0)
14631 v0.AuxInt = i0
14632 v0.Aux = s
14633 v0.AddArg(p)
14634 v0.AddArg(idx)
14635 v0.AddArg(mem)
14636 return true
14637 }
14638
14639
14640
14641 for {
14642 _ = v.Args[1]
14643 o0 := v.Args[0]
14644 if o0.Op != Op386ORL {
14645 break
14646 }
14647 _ = o0.Args[1]
14648 x0 := o0.Args[0]
14649 if x0.Op != Op386MOVWloadidx1 {
14650 break
14651 }
14652 i0 := x0.AuxInt
14653 s := x0.Aux
14654 mem := x0.Args[2]
14655 p := x0.Args[0]
14656 idx := x0.Args[1]
14657 s0 := o0.Args[1]
14658 if s0.Op != Op386SHLLconst {
14659 break
14660 }
14661 if s0.AuxInt != 16 {
14662 break
14663 }
14664 x1 := s0.Args[0]
14665 if x1.Op != Op386MOVBloadidx1 {
14666 break
14667 }
14668 i2 := x1.AuxInt
14669 if x1.Aux != s {
14670 break
14671 }
14672 _ = x1.Args[2]
14673 if idx != x1.Args[0] {
14674 break
14675 }
14676 if p != x1.Args[1] {
14677 break
14678 }
14679 if mem != x1.Args[2] {
14680 break
14681 }
14682 s1 := v.Args[1]
14683 if s1.Op != Op386SHLLconst {
14684 break
14685 }
14686 if s1.AuxInt != 24 {
14687 break
14688 }
14689 x2 := s1.Args[0]
14690 if x2.Op != Op386MOVBloadidx1 {
14691 break
14692 }
14693 i3 := x2.AuxInt
14694 if x2.Aux != s {
14695 break
14696 }
14697 _ = x2.Args[2]
14698 if p != x2.Args[0] {
14699 break
14700 }
14701 if idx != x2.Args[1] {
14702 break
14703 }
14704 if mem != x2.Args[2] {
14705 break
14706 }
14707 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
14708 break
14709 }
14710 b = mergePoint(b, x0, x1, x2)
14711 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
14712 v.reset(OpCopy)
14713 v.AddArg(v0)
14714 v0.AuxInt = i0
14715 v0.Aux = s
14716 v0.AddArg(p)
14717 v0.AddArg(idx)
14718 v0.AddArg(mem)
14719 return true
14720 }
14721 return false
14722 }
14723 func rewriteValue386_Op386ORL_30(v *Value) bool {
14724 b := v.Block
14725
14726
14727
14728 for {
14729 _ = v.Args[1]
14730 o0 := v.Args[0]
14731 if o0.Op != Op386ORL {
14732 break
14733 }
14734 _ = o0.Args[1]
14735 x0 := o0.Args[0]
14736 if x0.Op != Op386MOVWloadidx1 {
14737 break
14738 }
14739 i0 := x0.AuxInt
14740 s := x0.Aux
14741 mem := x0.Args[2]
14742 idx := x0.Args[0]
14743 p := x0.Args[1]
14744 s0 := o0.Args[1]
14745 if s0.Op != Op386SHLLconst {
14746 break
14747 }
14748 if s0.AuxInt != 16 {
14749 break
14750 }
14751 x1 := s0.Args[0]
14752 if x1.Op != Op386MOVBloadidx1 {
14753 break
14754 }
14755 i2 := x1.AuxInt
14756 if x1.Aux != s {
14757 break
14758 }
14759 _ = x1.Args[2]
14760 if idx != x1.Args[0] {
14761 break
14762 }
14763 if p != x1.Args[1] {
14764 break
14765 }
14766 if mem != x1.Args[2] {
14767 break
14768 }
14769 s1 := v.Args[1]
14770 if s1.Op != Op386SHLLconst {
14771 break
14772 }
14773 if s1.AuxInt != 24 {
14774 break
14775 }
14776 x2 := s1.Args[0]
14777 if x2.Op != Op386MOVBloadidx1 {
14778 break
14779 }
14780 i3 := x2.AuxInt
14781 if x2.Aux != s {
14782 break
14783 }
14784 _ = x2.Args[2]
14785 if p != x2.Args[0] {
14786 break
14787 }
14788 if idx != x2.Args[1] {
14789 break
14790 }
14791 if mem != x2.Args[2] {
14792 break
14793 }
14794 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
14795 break
14796 }
14797 b = mergePoint(b, x0, x1, x2)
14798 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
14799 v.reset(OpCopy)
14800 v.AddArg(v0)
14801 v0.AuxInt = i0
14802 v0.Aux = s
14803 v0.AddArg(p)
14804 v0.AddArg(idx)
14805 v0.AddArg(mem)
14806 return true
14807 }
14808
14809
14810
14811 for {
14812 _ = v.Args[1]
14813 o0 := v.Args[0]
14814 if o0.Op != Op386ORL {
14815 break
14816 }
14817 _ = o0.Args[1]
14818 s0 := o0.Args[0]
14819 if s0.Op != Op386SHLLconst {
14820 break
14821 }
14822 if s0.AuxInt != 16 {
14823 break
14824 }
14825 x1 := s0.Args[0]
14826 if x1.Op != Op386MOVBloadidx1 {
14827 break
14828 }
14829 i2 := x1.AuxInt
14830 s := x1.Aux
14831 mem := x1.Args[2]
14832 p := x1.Args[0]
14833 idx := x1.Args[1]
14834 x0 := o0.Args[1]
14835 if x0.Op != Op386MOVWloadidx1 {
14836 break
14837 }
14838 i0 := x0.AuxInt
14839 if x0.Aux != s {
14840 break
14841 }
14842 _ = x0.Args[2]
14843 if p != x0.Args[0] {
14844 break
14845 }
14846 if idx != x0.Args[1] {
14847 break
14848 }
14849 if mem != x0.Args[2] {
14850 break
14851 }
14852 s1 := v.Args[1]
14853 if s1.Op != Op386SHLLconst {
14854 break
14855 }
14856 if s1.AuxInt != 24 {
14857 break
14858 }
14859 x2 := s1.Args[0]
14860 if x2.Op != Op386MOVBloadidx1 {
14861 break
14862 }
14863 i3 := x2.AuxInt
14864 if x2.Aux != s {
14865 break
14866 }
14867 _ = x2.Args[2]
14868 if p != x2.Args[0] {
14869 break
14870 }
14871 if idx != x2.Args[1] {
14872 break
14873 }
14874 if mem != x2.Args[2] {
14875 break
14876 }
14877 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
14878 break
14879 }
14880 b = mergePoint(b, x0, x1, x2)
14881 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
14882 v.reset(OpCopy)
14883 v.AddArg(v0)
14884 v0.AuxInt = i0
14885 v0.Aux = s
14886 v0.AddArg(p)
14887 v0.AddArg(idx)
14888 v0.AddArg(mem)
14889 return true
14890 }
14891
14892
14893
14894 for {
14895 _ = v.Args[1]
14896 o0 := v.Args[0]
14897 if o0.Op != Op386ORL {
14898 break
14899 }
14900 _ = o0.Args[1]
14901 s0 := o0.Args[0]
14902 if s0.Op != Op386SHLLconst {
14903 break
14904 }
14905 if s0.AuxInt != 16 {
14906 break
14907 }
14908 x1 := s0.Args[0]
14909 if x1.Op != Op386MOVBloadidx1 {
14910 break
14911 }
14912 i2 := x1.AuxInt
14913 s := x1.Aux
14914 mem := x1.Args[2]
14915 idx := x1.Args[0]
14916 p := x1.Args[1]
14917 x0 := o0.Args[1]
14918 if x0.Op != Op386MOVWloadidx1 {
14919 break
14920 }
14921 i0 := x0.AuxInt
14922 if x0.Aux != s {
14923 break
14924 }
14925 _ = x0.Args[2]
14926 if p != x0.Args[0] {
14927 break
14928 }
14929 if idx != x0.Args[1] {
14930 break
14931 }
14932 if mem != x0.Args[2] {
14933 break
14934 }
14935 s1 := v.Args[1]
14936 if s1.Op != Op386SHLLconst {
14937 break
14938 }
14939 if s1.AuxInt != 24 {
14940 break
14941 }
14942 x2 := s1.Args[0]
14943 if x2.Op != Op386MOVBloadidx1 {
14944 break
14945 }
14946 i3 := x2.AuxInt
14947 if x2.Aux != s {
14948 break
14949 }
14950 _ = x2.Args[2]
14951 if p != x2.Args[0] {
14952 break
14953 }
14954 if idx != x2.Args[1] {
14955 break
14956 }
14957 if mem != x2.Args[2] {
14958 break
14959 }
14960 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
14961 break
14962 }
14963 b = mergePoint(b, x0, x1, x2)
14964 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
14965 v.reset(OpCopy)
14966 v.AddArg(v0)
14967 v0.AuxInt = i0
14968 v0.Aux = s
14969 v0.AddArg(p)
14970 v0.AddArg(idx)
14971 v0.AddArg(mem)
14972 return true
14973 }
14974
14975
14976
14977 for {
14978 _ = v.Args[1]
14979 o0 := v.Args[0]
14980 if o0.Op != Op386ORL {
14981 break
14982 }
14983 _ = o0.Args[1]
14984 s0 := o0.Args[0]
14985 if s0.Op != Op386SHLLconst {
14986 break
14987 }
14988 if s0.AuxInt != 16 {
14989 break
14990 }
14991 x1 := s0.Args[0]
14992 if x1.Op != Op386MOVBloadidx1 {
14993 break
14994 }
14995 i2 := x1.AuxInt
14996 s := x1.Aux
14997 mem := x1.Args[2]
14998 p := x1.Args[0]
14999 idx := x1.Args[1]
15000 x0 := o0.Args[1]
15001 if x0.Op != Op386MOVWloadidx1 {
15002 break
15003 }
15004 i0 := x0.AuxInt
15005 if x0.Aux != s {
15006 break
15007 }
15008 _ = x0.Args[2]
15009 if idx != x0.Args[0] {
15010 break
15011 }
15012 if p != x0.Args[1] {
15013 break
15014 }
15015 if mem != x0.Args[2] {
15016 break
15017 }
15018 s1 := v.Args[1]
15019 if s1.Op != Op386SHLLconst {
15020 break
15021 }
15022 if s1.AuxInt != 24 {
15023 break
15024 }
15025 x2 := s1.Args[0]
15026 if x2.Op != Op386MOVBloadidx1 {
15027 break
15028 }
15029 i3 := x2.AuxInt
15030 if x2.Aux != s {
15031 break
15032 }
15033 _ = x2.Args[2]
15034 if p != x2.Args[0] {
15035 break
15036 }
15037 if idx != x2.Args[1] {
15038 break
15039 }
15040 if mem != x2.Args[2] {
15041 break
15042 }
15043 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15044 break
15045 }
15046 b = mergePoint(b, x0, x1, x2)
15047 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15048 v.reset(OpCopy)
15049 v.AddArg(v0)
15050 v0.AuxInt = i0
15051 v0.Aux = s
15052 v0.AddArg(p)
15053 v0.AddArg(idx)
15054 v0.AddArg(mem)
15055 return true
15056 }
15057
15058
15059
15060 for {
15061 _ = v.Args[1]
15062 o0 := v.Args[0]
15063 if o0.Op != Op386ORL {
15064 break
15065 }
15066 _ = o0.Args[1]
15067 s0 := o0.Args[0]
15068 if s0.Op != Op386SHLLconst {
15069 break
15070 }
15071 if s0.AuxInt != 16 {
15072 break
15073 }
15074 x1 := s0.Args[0]
15075 if x1.Op != Op386MOVBloadidx1 {
15076 break
15077 }
15078 i2 := x1.AuxInt
15079 s := x1.Aux
15080 mem := x1.Args[2]
15081 idx := x1.Args[0]
15082 p := x1.Args[1]
15083 x0 := o0.Args[1]
15084 if x0.Op != Op386MOVWloadidx1 {
15085 break
15086 }
15087 i0 := x0.AuxInt
15088 if x0.Aux != s {
15089 break
15090 }
15091 _ = x0.Args[2]
15092 if idx != x0.Args[0] {
15093 break
15094 }
15095 if p != x0.Args[1] {
15096 break
15097 }
15098 if mem != x0.Args[2] {
15099 break
15100 }
15101 s1 := v.Args[1]
15102 if s1.Op != Op386SHLLconst {
15103 break
15104 }
15105 if s1.AuxInt != 24 {
15106 break
15107 }
15108 x2 := s1.Args[0]
15109 if x2.Op != Op386MOVBloadidx1 {
15110 break
15111 }
15112 i3 := x2.AuxInt
15113 if x2.Aux != s {
15114 break
15115 }
15116 _ = x2.Args[2]
15117 if p != x2.Args[0] {
15118 break
15119 }
15120 if idx != x2.Args[1] {
15121 break
15122 }
15123 if mem != x2.Args[2] {
15124 break
15125 }
15126 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15127 break
15128 }
15129 b = mergePoint(b, x0, x1, x2)
15130 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15131 v.reset(OpCopy)
15132 v.AddArg(v0)
15133 v0.AuxInt = i0
15134 v0.Aux = s
15135 v0.AddArg(p)
15136 v0.AddArg(idx)
15137 v0.AddArg(mem)
15138 return true
15139 }
15140
15141
15142
15143 for {
15144 _ = v.Args[1]
15145 o0 := v.Args[0]
15146 if o0.Op != Op386ORL {
15147 break
15148 }
15149 _ = o0.Args[1]
15150 x0 := o0.Args[0]
15151 if x0.Op != Op386MOVWloadidx1 {
15152 break
15153 }
15154 i0 := x0.AuxInt
15155 s := x0.Aux
15156 mem := x0.Args[2]
15157 p := x0.Args[0]
15158 idx := x0.Args[1]
15159 s0 := o0.Args[1]
15160 if s0.Op != Op386SHLLconst {
15161 break
15162 }
15163 if s0.AuxInt != 16 {
15164 break
15165 }
15166 x1 := s0.Args[0]
15167 if x1.Op != Op386MOVBloadidx1 {
15168 break
15169 }
15170 i2 := x1.AuxInt
15171 if x1.Aux != s {
15172 break
15173 }
15174 _ = x1.Args[2]
15175 if p != x1.Args[0] {
15176 break
15177 }
15178 if idx != x1.Args[1] {
15179 break
15180 }
15181 if mem != x1.Args[2] {
15182 break
15183 }
15184 s1 := v.Args[1]
15185 if s1.Op != Op386SHLLconst {
15186 break
15187 }
15188 if s1.AuxInt != 24 {
15189 break
15190 }
15191 x2 := s1.Args[0]
15192 if x2.Op != Op386MOVBloadidx1 {
15193 break
15194 }
15195 i3 := x2.AuxInt
15196 if x2.Aux != s {
15197 break
15198 }
15199 _ = x2.Args[2]
15200 if idx != x2.Args[0] {
15201 break
15202 }
15203 if p != x2.Args[1] {
15204 break
15205 }
15206 if mem != x2.Args[2] {
15207 break
15208 }
15209 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15210 break
15211 }
15212 b = mergePoint(b, x0, x1, x2)
15213 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15214 v.reset(OpCopy)
15215 v.AddArg(v0)
15216 v0.AuxInt = i0
15217 v0.Aux = s
15218 v0.AddArg(p)
15219 v0.AddArg(idx)
15220 v0.AddArg(mem)
15221 return true
15222 }
15223
15224
15225
15226 for {
15227 _ = v.Args[1]
15228 o0 := v.Args[0]
15229 if o0.Op != Op386ORL {
15230 break
15231 }
15232 _ = o0.Args[1]
15233 x0 := o0.Args[0]
15234 if x0.Op != Op386MOVWloadidx1 {
15235 break
15236 }
15237 i0 := x0.AuxInt
15238 s := x0.Aux
15239 mem := x0.Args[2]
15240 idx := x0.Args[0]
15241 p := x0.Args[1]
15242 s0 := o0.Args[1]
15243 if s0.Op != Op386SHLLconst {
15244 break
15245 }
15246 if s0.AuxInt != 16 {
15247 break
15248 }
15249 x1 := s0.Args[0]
15250 if x1.Op != Op386MOVBloadidx1 {
15251 break
15252 }
15253 i2 := x1.AuxInt
15254 if x1.Aux != s {
15255 break
15256 }
15257 _ = x1.Args[2]
15258 if p != x1.Args[0] {
15259 break
15260 }
15261 if idx != x1.Args[1] {
15262 break
15263 }
15264 if mem != x1.Args[2] {
15265 break
15266 }
15267 s1 := v.Args[1]
15268 if s1.Op != Op386SHLLconst {
15269 break
15270 }
15271 if s1.AuxInt != 24 {
15272 break
15273 }
15274 x2 := s1.Args[0]
15275 if x2.Op != Op386MOVBloadidx1 {
15276 break
15277 }
15278 i3 := x2.AuxInt
15279 if x2.Aux != s {
15280 break
15281 }
15282 _ = x2.Args[2]
15283 if idx != x2.Args[0] {
15284 break
15285 }
15286 if p != x2.Args[1] {
15287 break
15288 }
15289 if mem != x2.Args[2] {
15290 break
15291 }
15292 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15293 break
15294 }
15295 b = mergePoint(b, x0, x1, x2)
15296 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15297 v.reset(OpCopy)
15298 v.AddArg(v0)
15299 v0.AuxInt = i0
15300 v0.Aux = s
15301 v0.AddArg(p)
15302 v0.AddArg(idx)
15303 v0.AddArg(mem)
15304 return true
15305 }
15306
15307
15308
15309 for {
15310 _ = v.Args[1]
15311 o0 := v.Args[0]
15312 if o0.Op != Op386ORL {
15313 break
15314 }
15315 _ = o0.Args[1]
15316 x0 := o0.Args[0]
15317 if x0.Op != Op386MOVWloadidx1 {
15318 break
15319 }
15320 i0 := x0.AuxInt
15321 s := x0.Aux
15322 mem := x0.Args[2]
15323 p := x0.Args[0]
15324 idx := x0.Args[1]
15325 s0 := o0.Args[1]
15326 if s0.Op != Op386SHLLconst {
15327 break
15328 }
15329 if s0.AuxInt != 16 {
15330 break
15331 }
15332 x1 := s0.Args[0]
15333 if x1.Op != Op386MOVBloadidx1 {
15334 break
15335 }
15336 i2 := x1.AuxInt
15337 if x1.Aux != s {
15338 break
15339 }
15340 _ = x1.Args[2]
15341 if idx != x1.Args[0] {
15342 break
15343 }
15344 if p != x1.Args[1] {
15345 break
15346 }
15347 if mem != x1.Args[2] {
15348 break
15349 }
15350 s1 := v.Args[1]
15351 if s1.Op != Op386SHLLconst {
15352 break
15353 }
15354 if s1.AuxInt != 24 {
15355 break
15356 }
15357 x2 := s1.Args[0]
15358 if x2.Op != Op386MOVBloadidx1 {
15359 break
15360 }
15361 i3 := x2.AuxInt
15362 if x2.Aux != s {
15363 break
15364 }
15365 _ = x2.Args[2]
15366 if idx != x2.Args[0] {
15367 break
15368 }
15369 if p != x2.Args[1] {
15370 break
15371 }
15372 if mem != x2.Args[2] {
15373 break
15374 }
15375 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15376 break
15377 }
15378 b = mergePoint(b, x0, x1, x2)
15379 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15380 v.reset(OpCopy)
15381 v.AddArg(v0)
15382 v0.AuxInt = i0
15383 v0.Aux = s
15384 v0.AddArg(p)
15385 v0.AddArg(idx)
15386 v0.AddArg(mem)
15387 return true
15388 }
15389
15390
15391
15392 for {
15393 _ = v.Args[1]
15394 o0 := v.Args[0]
15395 if o0.Op != Op386ORL {
15396 break
15397 }
15398 _ = o0.Args[1]
15399 x0 := o0.Args[0]
15400 if x0.Op != Op386MOVWloadidx1 {
15401 break
15402 }
15403 i0 := x0.AuxInt
15404 s := x0.Aux
15405 mem := x0.Args[2]
15406 idx := x0.Args[0]
15407 p := x0.Args[1]
15408 s0 := o0.Args[1]
15409 if s0.Op != Op386SHLLconst {
15410 break
15411 }
15412 if s0.AuxInt != 16 {
15413 break
15414 }
15415 x1 := s0.Args[0]
15416 if x1.Op != Op386MOVBloadidx1 {
15417 break
15418 }
15419 i2 := x1.AuxInt
15420 if x1.Aux != s {
15421 break
15422 }
15423 _ = x1.Args[2]
15424 if idx != x1.Args[0] {
15425 break
15426 }
15427 if p != x1.Args[1] {
15428 break
15429 }
15430 if mem != x1.Args[2] {
15431 break
15432 }
15433 s1 := v.Args[1]
15434 if s1.Op != Op386SHLLconst {
15435 break
15436 }
15437 if s1.AuxInt != 24 {
15438 break
15439 }
15440 x2 := s1.Args[0]
15441 if x2.Op != Op386MOVBloadidx1 {
15442 break
15443 }
15444 i3 := x2.AuxInt
15445 if x2.Aux != s {
15446 break
15447 }
15448 _ = x2.Args[2]
15449 if idx != x2.Args[0] {
15450 break
15451 }
15452 if p != x2.Args[1] {
15453 break
15454 }
15455 if mem != x2.Args[2] {
15456 break
15457 }
15458 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15459 break
15460 }
15461 b = mergePoint(b, x0, x1, x2)
15462 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15463 v.reset(OpCopy)
15464 v.AddArg(v0)
15465 v0.AuxInt = i0
15466 v0.Aux = s
15467 v0.AddArg(p)
15468 v0.AddArg(idx)
15469 v0.AddArg(mem)
15470 return true
15471 }
15472
15473
15474
15475 for {
15476 _ = v.Args[1]
15477 o0 := v.Args[0]
15478 if o0.Op != Op386ORL {
15479 break
15480 }
15481 _ = o0.Args[1]
15482 s0 := o0.Args[0]
15483 if s0.Op != Op386SHLLconst {
15484 break
15485 }
15486 if s0.AuxInt != 16 {
15487 break
15488 }
15489 x1 := s0.Args[0]
15490 if x1.Op != Op386MOVBloadidx1 {
15491 break
15492 }
15493 i2 := x1.AuxInt
15494 s := x1.Aux
15495 mem := x1.Args[2]
15496 p := x1.Args[0]
15497 idx := x1.Args[1]
15498 x0 := o0.Args[1]
15499 if x0.Op != Op386MOVWloadidx1 {
15500 break
15501 }
15502 i0 := x0.AuxInt
15503 if x0.Aux != s {
15504 break
15505 }
15506 _ = x0.Args[2]
15507 if p != x0.Args[0] {
15508 break
15509 }
15510 if idx != x0.Args[1] {
15511 break
15512 }
15513 if mem != x0.Args[2] {
15514 break
15515 }
15516 s1 := v.Args[1]
15517 if s1.Op != Op386SHLLconst {
15518 break
15519 }
15520 if s1.AuxInt != 24 {
15521 break
15522 }
15523 x2 := s1.Args[0]
15524 if x2.Op != Op386MOVBloadidx1 {
15525 break
15526 }
15527 i3 := x2.AuxInt
15528 if x2.Aux != s {
15529 break
15530 }
15531 _ = x2.Args[2]
15532 if idx != x2.Args[0] {
15533 break
15534 }
15535 if p != x2.Args[1] {
15536 break
15537 }
15538 if mem != x2.Args[2] {
15539 break
15540 }
15541 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15542 break
15543 }
15544 b = mergePoint(b, x0, x1, x2)
15545 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15546 v.reset(OpCopy)
15547 v.AddArg(v0)
15548 v0.AuxInt = i0
15549 v0.Aux = s
15550 v0.AddArg(p)
15551 v0.AddArg(idx)
15552 v0.AddArg(mem)
15553 return true
15554 }
15555 return false
15556 }
15557 func rewriteValue386_Op386ORL_40(v *Value) bool {
15558 b := v.Block
15559
15560
15561
15562 for {
15563 _ = v.Args[1]
15564 o0 := v.Args[0]
15565 if o0.Op != Op386ORL {
15566 break
15567 }
15568 _ = o0.Args[1]
15569 s0 := o0.Args[0]
15570 if s0.Op != Op386SHLLconst {
15571 break
15572 }
15573 if s0.AuxInt != 16 {
15574 break
15575 }
15576 x1 := s0.Args[0]
15577 if x1.Op != Op386MOVBloadidx1 {
15578 break
15579 }
15580 i2 := x1.AuxInt
15581 s := x1.Aux
15582 mem := x1.Args[2]
15583 idx := x1.Args[0]
15584 p := x1.Args[1]
15585 x0 := o0.Args[1]
15586 if x0.Op != Op386MOVWloadidx1 {
15587 break
15588 }
15589 i0 := x0.AuxInt
15590 if x0.Aux != s {
15591 break
15592 }
15593 _ = x0.Args[2]
15594 if p != x0.Args[0] {
15595 break
15596 }
15597 if idx != x0.Args[1] {
15598 break
15599 }
15600 if mem != x0.Args[2] {
15601 break
15602 }
15603 s1 := v.Args[1]
15604 if s1.Op != Op386SHLLconst {
15605 break
15606 }
15607 if s1.AuxInt != 24 {
15608 break
15609 }
15610 x2 := s1.Args[0]
15611 if x2.Op != Op386MOVBloadidx1 {
15612 break
15613 }
15614 i3 := x2.AuxInt
15615 if x2.Aux != s {
15616 break
15617 }
15618 _ = x2.Args[2]
15619 if idx != x2.Args[0] {
15620 break
15621 }
15622 if p != x2.Args[1] {
15623 break
15624 }
15625 if mem != x2.Args[2] {
15626 break
15627 }
15628 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15629 break
15630 }
15631 b = mergePoint(b, x0, x1, x2)
15632 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15633 v.reset(OpCopy)
15634 v.AddArg(v0)
15635 v0.AuxInt = i0
15636 v0.Aux = s
15637 v0.AddArg(p)
15638 v0.AddArg(idx)
15639 v0.AddArg(mem)
15640 return true
15641 }
15642
15643
15644
15645 for {
15646 _ = v.Args[1]
15647 o0 := v.Args[0]
15648 if o0.Op != Op386ORL {
15649 break
15650 }
15651 _ = o0.Args[1]
15652 s0 := o0.Args[0]
15653 if s0.Op != Op386SHLLconst {
15654 break
15655 }
15656 if s0.AuxInt != 16 {
15657 break
15658 }
15659 x1 := s0.Args[0]
15660 if x1.Op != Op386MOVBloadidx1 {
15661 break
15662 }
15663 i2 := x1.AuxInt
15664 s := x1.Aux
15665 mem := x1.Args[2]
15666 p := x1.Args[0]
15667 idx := x1.Args[1]
15668 x0 := o0.Args[1]
15669 if x0.Op != Op386MOVWloadidx1 {
15670 break
15671 }
15672 i0 := x0.AuxInt
15673 if x0.Aux != s {
15674 break
15675 }
15676 _ = x0.Args[2]
15677 if idx != x0.Args[0] {
15678 break
15679 }
15680 if p != x0.Args[1] {
15681 break
15682 }
15683 if mem != x0.Args[2] {
15684 break
15685 }
15686 s1 := v.Args[1]
15687 if s1.Op != Op386SHLLconst {
15688 break
15689 }
15690 if s1.AuxInt != 24 {
15691 break
15692 }
15693 x2 := s1.Args[0]
15694 if x2.Op != Op386MOVBloadidx1 {
15695 break
15696 }
15697 i3 := x2.AuxInt
15698 if x2.Aux != s {
15699 break
15700 }
15701 _ = x2.Args[2]
15702 if idx != x2.Args[0] {
15703 break
15704 }
15705 if p != x2.Args[1] {
15706 break
15707 }
15708 if mem != x2.Args[2] {
15709 break
15710 }
15711 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15712 break
15713 }
15714 b = mergePoint(b, x0, x1, x2)
15715 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15716 v.reset(OpCopy)
15717 v.AddArg(v0)
15718 v0.AuxInt = i0
15719 v0.Aux = s
15720 v0.AddArg(p)
15721 v0.AddArg(idx)
15722 v0.AddArg(mem)
15723 return true
15724 }
15725
15726
15727
15728 for {
15729 _ = v.Args[1]
15730 o0 := v.Args[0]
15731 if o0.Op != Op386ORL {
15732 break
15733 }
15734 _ = o0.Args[1]
15735 s0 := o0.Args[0]
15736 if s0.Op != Op386SHLLconst {
15737 break
15738 }
15739 if s0.AuxInt != 16 {
15740 break
15741 }
15742 x1 := s0.Args[0]
15743 if x1.Op != Op386MOVBloadidx1 {
15744 break
15745 }
15746 i2 := x1.AuxInt
15747 s := x1.Aux
15748 mem := x1.Args[2]
15749 idx := x1.Args[0]
15750 p := x1.Args[1]
15751 x0 := o0.Args[1]
15752 if x0.Op != Op386MOVWloadidx1 {
15753 break
15754 }
15755 i0 := x0.AuxInt
15756 if x0.Aux != s {
15757 break
15758 }
15759 _ = x0.Args[2]
15760 if idx != x0.Args[0] {
15761 break
15762 }
15763 if p != x0.Args[1] {
15764 break
15765 }
15766 if mem != x0.Args[2] {
15767 break
15768 }
15769 s1 := v.Args[1]
15770 if s1.Op != Op386SHLLconst {
15771 break
15772 }
15773 if s1.AuxInt != 24 {
15774 break
15775 }
15776 x2 := s1.Args[0]
15777 if x2.Op != Op386MOVBloadidx1 {
15778 break
15779 }
15780 i3 := x2.AuxInt
15781 if x2.Aux != s {
15782 break
15783 }
15784 _ = x2.Args[2]
15785 if idx != x2.Args[0] {
15786 break
15787 }
15788 if p != x2.Args[1] {
15789 break
15790 }
15791 if mem != x2.Args[2] {
15792 break
15793 }
15794 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15795 break
15796 }
15797 b = mergePoint(b, x0, x1, x2)
15798 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15799 v.reset(OpCopy)
15800 v.AddArg(v0)
15801 v0.AuxInt = i0
15802 v0.Aux = s
15803 v0.AddArg(p)
15804 v0.AddArg(idx)
15805 v0.AddArg(mem)
15806 return true
15807 }
15808
15809
15810
15811 for {
15812 _ = v.Args[1]
15813 s1 := v.Args[0]
15814 if s1.Op != Op386SHLLconst {
15815 break
15816 }
15817 if s1.AuxInt != 24 {
15818 break
15819 }
15820 x2 := s1.Args[0]
15821 if x2.Op != Op386MOVBloadidx1 {
15822 break
15823 }
15824 i3 := x2.AuxInt
15825 s := x2.Aux
15826 mem := x2.Args[2]
15827 p := x2.Args[0]
15828 idx := x2.Args[1]
15829 o0 := v.Args[1]
15830 if o0.Op != Op386ORL {
15831 break
15832 }
15833 _ = o0.Args[1]
15834 x0 := o0.Args[0]
15835 if x0.Op != Op386MOVWloadidx1 {
15836 break
15837 }
15838 i0 := x0.AuxInt
15839 if x0.Aux != s {
15840 break
15841 }
15842 _ = x0.Args[2]
15843 if p != x0.Args[0] {
15844 break
15845 }
15846 if idx != x0.Args[1] {
15847 break
15848 }
15849 if mem != x0.Args[2] {
15850 break
15851 }
15852 s0 := o0.Args[1]
15853 if s0.Op != Op386SHLLconst {
15854 break
15855 }
15856 if s0.AuxInt != 16 {
15857 break
15858 }
15859 x1 := s0.Args[0]
15860 if x1.Op != Op386MOVBloadidx1 {
15861 break
15862 }
15863 i2 := x1.AuxInt
15864 if x1.Aux != s {
15865 break
15866 }
15867 _ = x1.Args[2]
15868 if p != x1.Args[0] {
15869 break
15870 }
15871 if idx != x1.Args[1] {
15872 break
15873 }
15874 if mem != x1.Args[2] {
15875 break
15876 }
15877 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15878 break
15879 }
15880 b = mergePoint(b, x0, x1, x2)
15881 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15882 v.reset(OpCopy)
15883 v.AddArg(v0)
15884 v0.AuxInt = i0
15885 v0.Aux = s
15886 v0.AddArg(p)
15887 v0.AddArg(idx)
15888 v0.AddArg(mem)
15889 return true
15890 }
15891
15892
15893
15894 for {
15895 _ = v.Args[1]
15896 s1 := v.Args[0]
15897 if s1.Op != Op386SHLLconst {
15898 break
15899 }
15900 if s1.AuxInt != 24 {
15901 break
15902 }
15903 x2 := s1.Args[0]
15904 if x2.Op != Op386MOVBloadidx1 {
15905 break
15906 }
15907 i3 := x2.AuxInt
15908 s := x2.Aux
15909 mem := x2.Args[2]
15910 idx := x2.Args[0]
15911 p := x2.Args[1]
15912 o0 := v.Args[1]
15913 if o0.Op != Op386ORL {
15914 break
15915 }
15916 _ = o0.Args[1]
15917 x0 := o0.Args[0]
15918 if x0.Op != Op386MOVWloadidx1 {
15919 break
15920 }
15921 i0 := x0.AuxInt
15922 if x0.Aux != s {
15923 break
15924 }
15925 _ = x0.Args[2]
15926 if p != x0.Args[0] {
15927 break
15928 }
15929 if idx != x0.Args[1] {
15930 break
15931 }
15932 if mem != x0.Args[2] {
15933 break
15934 }
15935 s0 := o0.Args[1]
15936 if s0.Op != Op386SHLLconst {
15937 break
15938 }
15939 if s0.AuxInt != 16 {
15940 break
15941 }
15942 x1 := s0.Args[0]
15943 if x1.Op != Op386MOVBloadidx1 {
15944 break
15945 }
15946 i2 := x1.AuxInt
15947 if x1.Aux != s {
15948 break
15949 }
15950 _ = x1.Args[2]
15951 if p != x1.Args[0] {
15952 break
15953 }
15954 if idx != x1.Args[1] {
15955 break
15956 }
15957 if mem != x1.Args[2] {
15958 break
15959 }
15960 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
15961 break
15962 }
15963 b = mergePoint(b, x0, x1, x2)
15964 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
15965 v.reset(OpCopy)
15966 v.AddArg(v0)
15967 v0.AuxInt = i0
15968 v0.Aux = s
15969 v0.AddArg(p)
15970 v0.AddArg(idx)
15971 v0.AddArg(mem)
15972 return true
15973 }
15974
15975
15976
15977 for {
15978 _ = v.Args[1]
15979 s1 := v.Args[0]
15980 if s1.Op != Op386SHLLconst {
15981 break
15982 }
15983 if s1.AuxInt != 24 {
15984 break
15985 }
15986 x2 := s1.Args[0]
15987 if x2.Op != Op386MOVBloadidx1 {
15988 break
15989 }
15990 i3 := x2.AuxInt
15991 s := x2.Aux
15992 mem := x2.Args[2]
15993 p := x2.Args[0]
15994 idx := x2.Args[1]
15995 o0 := v.Args[1]
15996 if o0.Op != Op386ORL {
15997 break
15998 }
15999 _ = o0.Args[1]
16000 x0 := o0.Args[0]
16001 if x0.Op != Op386MOVWloadidx1 {
16002 break
16003 }
16004 i0 := x0.AuxInt
16005 if x0.Aux != s {
16006 break
16007 }
16008 _ = x0.Args[2]
16009 if idx != x0.Args[0] {
16010 break
16011 }
16012 if p != x0.Args[1] {
16013 break
16014 }
16015 if mem != x0.Args[2] {
16016 break
16017 }
16018 s0 := o0.Args[1]
16019 if s0.Op != Op386SHLLconst {
16020 break
16021 }
16022 if s0.AuxInt != 16 {
16023 break
16024 }
16025 x1 := s0.Args[0]
16026 if x1.Op != Op386MOVBloadidx1 {
16027 break
16028 }
16029 i2 := x1.AuxInt
16030 if x1.Aux != s {
16031 break
16032 }
16033 _ = x1.Args[2]
16034 if p != x1.Args[0] {
16035 break
16036 }
16037 if idx != x1.Args[1] {
16038 break
16039 }
16040 if mem != x1.Args[2] {
16041 break
16042 }
16043 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16044 break
16045 }
16046 b = mergePoint(b, x0, x1, x2)
16047 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16048 v.reset(OpCopy)
16049 v.AddArg(v0)
16050 v0.AuxInt = i0
16051 v0.Aux = s
16052 v0.AddArg(p)
16053 v0.AddArg(idx)
16054 v0.AddArg(mem)
16055 return true
16056 }
16057
16058
16059
16060 for {
16061 _ = v.Args[1]
16062 s1 := v.Args[0]
16063 if s1.Op != Op386SHLLconst {
16064 break
16065 }
16066 if s1.AuxInt != 24 {
16067 break
16068 }
16069 x2 := s1.Args[0]
16070 if x2.Op != Op386MOVBloadidx1 {
16071 break
16072 }
16073 i3 := x2.AuxInt
16074 s := x2.Aux
16075 mem := x2.Args[2]
16076 idx := x2.Args[0]
16077 p := x2.Args[1]
16078 o0 := v.Args[1]
16079 if o0.Op != Op386ORL {
16080 break
16081 }
16082 _ = o0.Args[1]
16083 x0 := o0.Args[0]
16084 if x0.Op != Op386MOVWloadidx1 {
16085 break
16086 }
16087 i0 := x0.AuxInt
16088 if x0.Aux != s {
16089 break
16090 }
16091 _ = x0.Args[2]
16092 if idx != x0.Args[0] {
16093 break
16094 }
16095 if p != x0.Args[1] {
16096 break
16097 }
16098 if mem != x0.Args[2] {
16099 break
16100 }
16101 s0 := o0.Args[1]
16102 if s0.Op != Op386SHLLconst {
16103 break
16104 }
16105 if s0.AuxInt != 16 {
16106 break
16107 }
16108 x1 := s0.Args[0]
16109 if x1.Op != Op386MOVBloadidx1 {
16110 break
16111 }
16112 i2 := x1.AuxInt
16113 if x1.Aux != s {
16114 break
16115 }
16116 _ = x1.Args[2]
16117 if p != x1.Args[0] {
16118 break
16119 }
16120 if idx != x1.Args[1] {
16121 break
16122 }
16123 if mem != x1.Args[2] {
16124 break
16125 }
16126 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16127 break
16128 }
16129 b = mergePoint(b, x0, x1, x2)
16130 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16131 v.reset(OpCopy)
16132 v.AddArg(v0)
16133 v0.AuxInt = i0
16134 v0.Aux = s
16135 v0.AddArg(p)
16136 v0.AddArg(idx)
16137 v0.AddArg(mem)
16138 return true
16139 }
16140
16141
16142
16143 for {
16144 _ = v.Args[1]
16145 s1 := v.Args[0]
16146 if s1.Op != Op386SHLLconst {
16147 break
16148 }
16149 if s1.AuxInt != 24 {
16150 break
16151 }
16152 x2 := s1.Args[0]
16153 if x2.Op != Op386MOVBloadidx1 {
16154 break
16155 }
16156 i3 := x2.AuxInt
16157 s := x2.Aux
16158 mem := x2.Args[2]
16159 p := x2.Args[0]
16160 idx := x2.Args[1]
16161 o0 := v.Args[1]
16162 if o0.Op != Op386ORL {
16163 break
16164 }
16165 _ = o0.Args[1]
16166 x0 := o0.Args[0]
16167 if x0.Op != Op386MOVWloadidx1 {
16168 break
16169 }
16170 i0 := x0.AuxInt
16171 if x0.Aux != s {
16172 break
16173 }
16174 _ = x0.Args[2]
16175 if p != x0.Args[0] {
16176 break
16177 }
16178 if idx != x0.Args[1] {
16179 break
16180 }
16181 if mem != x0.Args[2] {
16182 break
16183 }
16184 s0 := o0.Args[1]
16185 if s0.Op != Op386SHLLconst {
16186 break
16187 }
16188 if s0.AuxInt != 16 {
16189 break
16190 }
16191 x1 := s0.Args[0]
16192 if x1.Op != Op386MOVBloadidx1 {
16193 break
16194 }
16195 i2 := x1.AuxInt
16196 if x1.Aux != s {
16197 break
16198 }
16199 _ = x1.Args[2]
16200 if idx != x1.Args[0] {
16201 break
16202 }
16203 if p != x1.Args[1] {
16204 break
16205 }
16206 if mem != x1.Args[2] {
16207 break
16208 }
16209 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16210 break
16211 }
16212 b = mergePoint(b, x0, x1, x2)
16213 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16214 v.reset(OpCopy)
16215 v.AddArg(v0)
16216 v0.AuxInt = i0
16217 v0.Aux = s
16218 v0.AddArg(p)
16219 v0.AddArg(idx)
16220 v0.AddArg(mem)
16221 return true
16222 }
16223
16224
16225
16226 for {
16227 _ = v.Args[1]
16228 s1 := v.Args[0]
16229 if s1.Op != Op386SHLLconst {
16230 break
16231 }
16232 if s1.AuxInt != 24 {
16233 break
16234 }
16235 x2 := s1.Args[0]
16236 if x2.Op != Op386MOVBloadidx1 {
16237 break
16238 }
16239 i3 := x2.AuxInt
16240 s := x2.Aux
16241 mem := x2.Args[2]
16242 idx := x2.Args[0]
16243 p := x2.Args[1]
16244 o0 := v.Args[1]
16245 if o0.Op != Op386ORL {
16246 break
16247 }
16248 _ = o0.Args[1]
16249 x0 := o0.Args[0]
16250 if x0.Op != Op386MOVWloadidx1 {
16251 break
16252 }
16253 i0 := x0.AuxInt
16254 if x0.Aux != s {
16255 break
16256 }
16257 _ = x0.Args[2]
16258 if p != x0.Args[0] {
16259 break
16260 }
16261 if idx != x0.Args[1] {
16262 break
16263 }
16264 if mem != x0.Args[2] {
16265 break
16266 }
16267 s0 := o0.Args[1]
16268 if s0.Op != Op386SHLLconst {
16269 break
16270 }
16271 if s0.AuxInt != 16 {
16272 break
16273 }
16274 x1 := s0.Args[0]
16275 if x1.Op != Op386MOVBloadidx1 {
16276 break
16277 }
16278 i2 := x1.AuxInt
16279 if x1.Aux != s {
16280 break
16281 }
16282 _ = x1.Args[2]
16283 if idx != x1.Args[0] {
16284 break
16285 }
16286 if p != x1.Args[1] {
16287 break
16288 }
16289 if mem != x1.Args[2] {
16290 break
16291 }
16292 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16293 break
16294 }
16295 b = mergePoint(b, x0, x1, x2)
16296 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16297 v.reset(OpCopy)
16298 v.AddArg(v0)
16299 v0.AuxInt = i0
16300 v0.Aux = s
16301 v0.AddArg(p)
16302 v0.AddArg(idx)
16303 v0.AddArg(mem)
16304 return true
16305 }
16306
16307
16308
16309 for {
16310 _ = v.Args[1]
16311 s1 := v.Args[0]
16312 if s1.Op != Op386SHLLconst {
16313 break
16314 }
16315 if s1.AuxInt != 24 {
16316 break
16317 }
16318 x2 := s1.Args[0]
16319 if x2.Op != Op386MOVBloadidx1 {
16320 break
16321 }
16322 i3 := x2.AuxInt
16323 s := x2.Aux
16324 mem := x2.Args[2]
16325 p := x2.Args[0]
16326 idx := x2.Args[1]
16327 o0 := v.Args[1]
16328 if o0.Op != Op386ORL {
16329 break
16330 }
16331 _ = o0.Args[1]
16332 x0 := o0.Args[0]
16333 if x0.Op != Op386MOVWloadidx1 {
16334 break
16335 }
16336 i0 := x0.AuxInt
16337 if x0.Aux != s {
16338 break
16339 }
16340 _ = x0.Args[2]
16341 if idx != x0.Args[0] {
16342 break
16343 }
16344 if p != x0.Args[1] {
16345 break
16346 }
16347 if mem != x0.Args[2] {
16348 break
16349 }
16350 s0 := o0.Args[1]
16351 if s0.Op != Op386SHLLconst {
16352 break
16353 }
16354 if s0.AuxInt != 16 {
16355 break
16356 }
16357 x1 := s0.Args[0]
16358 if x1.Op != Op386MOVBloadidx1 {
16359 break
16360 }
16361 i2 := x1.AuxInt
16362 if x1.Aux != s {
16363 break
16364 }
16365 _ = x1.Args[2]
16366 if idx != x1.Args[0] {
16367 break
16368 }
16369 if p != x1.Args[1] {
16370 break
16371 }
16372 if mem != x1.Args[2] {
16373 break
16374 }
16375 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16376 break
16377 }
16378 b = mergePoint(b, x0, x1, x2)
16379 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16380 v.reset(OpCopy)
16381 v.AddArg(v0)
16382 v0.AuxInt = i0
16383 v0.Aux = s
16384 v0.AddArg(p)
16385 v0.AddArg(idx)
16386 v0.AddArg(mem)
16387 return true
16388 }
16389 return false
16390 }
16391 func rewriteValue386_Op386ORL_50(v *Value) bool {
16392 b := v.Block
16393
16394
16395
16396 for {
16397 _ = v.Args[1]
16398 s1 := v.Args[0]
16399 if s1.Op != Op386SHLLconst {
16400 break
16401 }
16402 if s1.AuxInt != 24 {
16403 break
16404 }
16405 x2 := s1.Args[0]
16406 if x2.Op != Op386MOVBloadidx1 {
16407 break
16408 }
16409 i3 := x2.AuxInt
16410 s := x2.Aux
16411 mem := x2.Args[2]
16412 idx := x2.Args[0]
16413 p := x2.Args[1]
16414 o0 := v.Args[1]
16415 if o0.Op != Op386ORL {
16416 break
16417 }
16418 _ = o0.Args[1]
16419 x0 := o0.Args[0]
16420 if x0.Op != Op386MOVWloadidx1 {
16421 break
16422 }
16423 i0 := x0.AuxInt
16424 if x0.Aux != s {
16425 break
16426 }
16427 _ = x0.Args[2]
16428 if idx != x0.Args[0] {
16429 break
16430 }
16431 if p != x0.Args[1] {
16432 break
16433 }
16434 if mem != x0.Args[2] {
16435 break
16436 }
16437 s0 := o0.Args[1]
16438 if s0.Op != Op386SHLLconst {
16439 break
16440 }
16441 if s0.AuxInt != 16 {
16442 break
16443 }
16444 x1 := s0.Args[0]
16445 if x1.Op != Op386MOVBloadidx1 {
16446 break
16447 }
16448 i2 := x1.AuxInt
16449 if x1.Aux != s {
16450 break
16451 }
16452 _ = x1.Args[2]
16453 if idx != x1.Args[0] {
16454 break
16455 }
16456 if p != x1.Args[1] {
16457 break
16458 }
16459 if mem != x1.Args[2] {
16460 break
16461 }
16462 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16463 break
16464 }
16465 b = mergePoint(b, x0, x1, x2)
16466 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16467 v.reset(OpCopy)
16468 v.AddArg(v0)
16469 v0.AuxInt = i0
16470 v0.Aux = s
16471 v0.AddArg(p)
16472 v0.AddArg(idx)
16473 v0.AddArg(mem)
16474 return true
16475 }
16476
16477
16478
16479 for {
16480 _ = v.Args[1]
16481 s1 := v.Args[0]
16482 if s1.Op != Op386SHLLconst {
16483 break
16484 }
16485 if s1.AuxInt != 24 {
16486 break
16487 }
16488 x2 := s1.Args[0]
16489 if x2.Op != Op386MOVBloadidx1 {
16490 break
16491 }
16492 i3 := x2.AuxInt
16493 s := x2.Aux
16494 mem := x2.Args[2]
16495 p := x2.Args[0]
16496 idx := x2.Args[1]
16497 o0 := v.Args[1]
16498 if o0.Op != Op386ORL {
16499 break
16500 }
16501 _ = o0.Args[1]
16502 s0 := o0.Args[0]
16503 if s0.Op != Op386SHLLconst {
16504 break
16505 }
16506 if s0.AuxInt != 16 {
16507 break
16508 }
16509 x1 := s0.Args[0]
16510 if x1.Op != Op386MOVBloadidx1 {
16511 break
16512 }
16513 i2 := x1.AuxInt
16514 if x1.Aux != s {
16515 break
16516 }
16517 _ = x1.Args[2]
16518 if p != x1.Args[0] {
16519 break
16520 }
16521 if idx != x1.Args[1] {
16522 break
16523 }
16524 if mem != x1.Args[2] {
16525 break
16526 }
16527 x0 := o0.Args[1]
16528 if x0.Op != Op386MOVWloadidx1 {
16529 break
16530 }
16531 i0 := x0.AuxInt
16532 if x0.Aux != s {
16533 break
16534 }
16535 _ = x0.Args[2]
16536 if p != x0.Args[0] {
16537 break
16538 }
16539 if idx != x0.Args[1] {
16540 break
16541 }
16542 if mem != x0.Args[2] {
16543 break
16544 }
16545 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16546 break
16547 }
16548 b = mergePoint(b, x0, x1, x2)
16549 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16550 v.reset(OpCopy)
16551 v.AddArg(v0)
16552 v0.AuxInt = i0
16553 v0.Aux = s
16554 v0.AddArg(p)
16555 v0.AddArg(idx)
16556 v0.AddArg(mem)
16557 return true
16558 }
16559
16560
16561
16562 for {
16563 _ = v.Args[1]
16564 s1 := v.Args[0]
16565 if s1.Op != Op386SHLLconst {
16566 break
16567 }
16568 if s1.AuxInt != 24 {
16569 break
16570 }
16571 x2 := s1.Args[0]
16572 if x2.Op != Op386MOVBloadidx1 {
16573 break
16574 }
16575 i3 := x2.AuxInt
16576 s := x2.Aux
16577 mem := x2.Args[2]
16578 idx := x2.Args[0]
16579 p := x2.Args[1]
16580 o0 := v.Args[1]
16581 if o0.Op != Op386ORL {
16582 break
16583 }
16584 _ = o0.Args[1]
16585 s0 := o0.Args[0]
16586 if s0.Op != Op386SHLLconst {
16587 break
16588 }
16589 if s0.AuxInt != 16 {
16590 break
16591 }
16592 x1 := s0.Args[0]
16593 if x1.Op != Op386MOVBloadidx1 {
16594 break
16595 }
16596 i2 := x1.AuxInt
16597 if x1.Aux != s {
16598 break
16599 }
16600 _ = x1.Args[2]
16601 if p != x1.Args[0] {
16602 break
16603 }
16604 if idx != x1.Args[1] {
16605 break
16606 }
16607 if mem != x1.Args[2] {
16608 break
16609 }
16610 x0 := o0.Args[1]
16611 if x0.Op != Op386MOVWloadidx1 {
16612 break
16613 }
16614 i0 := x0.AuxInt
16615 if x0.Aux != s {
16616 break
16617 }
16618 _ = x0.Args[2]
16619 if p != x0.Args[0] {
16620 break
16621 }
16622 if idx != x0.Args[1] {
16623 break
16624 }
16625 if mem != x0.Args[2] {
16626 break
16627 }
16628 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16629 break
16630 }
16631 b = mergePoint(b, x0, x1, x2)
16632 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16633 v.reset(OpCopy)
16634 v.AddArg(v0)
16635 v0.AuxInt = i0
16636 v0.Aux = s
16637 v0.AddArg(p)
16638 v0.AddArg(idx)
16639 v0.AddArg(mem)
16640 return true
16641 }
16642
16643
16644
16645 for {
16646 _ = v.Args[1]
16647 s1 := v.Args[0]
16648 if s1.Op != Op386SHLLconst {
16649 break
16650 }
16651 if s1.AuxInt != 24 {
16652 break
16653 }
16654 x2 := s1.Args[0]
16655 if x2.Op != Op386MOVBloadidx1 {
16656 break
16657 }
16658 i3 := x2.AuxInt
16659 s := x2.Aux
16660 mem := x2.Args[2]
16661 p := x2.Args[0]
16662 idx := x2.Args[1]
16663 o0 := v.Args[1]
16664 if o0.Op != Op386ORL {
16665 break
16666 }
16667 _ = o0.Args[1]
16668 s0 := o0.Args[0]
16669 if s0.Op != Op386SHLLconst {
16670 break
16671 }
16672 if s0.AuxInt != 16 {
16673 break
16674 }
16675 x1 := s0.Args[0]
16676 if x1.Op != Op386MOVBloadidx1 {
16677 break
16678 }
16679 i2 := x1.AuxInt
16680 if x1.Aux != s {
16681 break
16682 }
16683 _ = x1.Args[2]
16684 if idx != x1.Args[0] {
16685 break
16686 }
16687 if p != x1.Args[1] {
16688 break
16689 }
16690 if mem != x1.Args[2] {
16691 break
16692 }
16693 x0 := o0.Args[1]
16694 if x0.Op != Op386MOVWloadidx1 {
16695 break
16696 }
16697 i0 := x0.AuxInt
16698 if x0.Aux != s {
16699 break
16700 }
16701 _ = x0.Args[2]
16702 if p != x0.Args[0] {
16703 break
16704 }
16705 if idx != x0.Args[1] {
16706 break
16707 }
16708 if mem != x0.Args[2] {
16709 break
16710 }
16711 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16712 break
16713 }
16714 b = mergePoint(b, x0, x1, x2)
16715 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16716 v.reset(OpCopy)
16717 v.AddArg(v0)
16718 v0.AuxInt = i0
16719 v0.Aux = s
16720 v0.AddArg(p)
16721 v0.AddArg(idx)
16722 v0.AddArg(mem)
16723 return true
16724 }
16725
16726
16727
16728 for {
16729 _ = v.Args[1]
16730 s1 := v.Args[0]
16731 if s1.Op != Op386SHLLconst {
16732 break
16733 }
16734 if s1.AuxInt != 24 {
16735 break
16736 }
16737 x2 := s1.Args[0]
16738 if x2.Op != Op386MOVBloadidx1 {
16739 break
16740 }
16741 i3 := x2.AuxInt
16742 s := x2.Aux
16743 mem := x2.Args[2]
16744 idx := x2.Args[0]
16745 p := x2.Args[1]
16746 o0 := v.Args[1]
16747 if o0.Op != Op386ORL {
16748 break
16749 }
16750 _ = o0.Args[1]
16751 s0 := o0.Args[0]
16752 if s0.Op != Op386SHLLconst {
16753 break
16754 }
16755 if s0.AuxInt != 16 {
16756 break
16757 }
16758 x1 := s0.Args[0]
16759 if x1.Op != Op386MOVBloadidx1 {
16760 break
16761 }
16762 i2 := x1.AuxInt
16763 if x1.Aux != s {
16764 break
16765 }
16766 _ = x1.Args[2]
16767 if idx != x1.Args[0] {
16768 break
16769 }
16770 if p != x1.Args[1] {
16771 break
16772 }
16773 if mem != x1.Args[2] {
16774 break
16775 }
16776 x0 := o0.Args[1]
16777 if x0.Op != Op386MOVWloadidx1 {
16778 break
16779 }
16780 i0 := x0.AuxInt
16781 if x0.Aux != s {
16782 break
16783 }
16784 _ = x0.Args[2]
16785 if p != x0.Args[0] {
16786 break
16787 }
16788 if idx != x0.Args[1] {
16789 break
16790 }
16791 if mem != x0.Args[2] {
16792 break
16793 }
16794 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16795 break
16796 }
16797 b = mergePoint(b, x0, x1, x2)
16798 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16799 v.reset(OpCopy)
16800 v.AddArg(v0)
16801 v0.AuxInt = i0
16802 v0.Aux = s
16803 v0.AddArg(p)
16804 v0.AddArg(idx)
16805 v0.AddArg(mem)
16806 return true
16807 }
16808
16809
16810
16811 for {
16812 _ = v.Args[1]
16813 s1 := v.Args[0]
16814 if s1.Op != Op386SHLLconst {
16815 break
16816 }
16817 if s1.AuxInt != 24 {
16818 break
16819 }
16820 x2 := s1.Args[0]
16821 if x2.Op != Op386MOVBloadidx1 {
16822 break
16823 }
16824 i3 := x2.AuxInt
16825 s := x2.Aux
16826 mem := x2.Args[2]
16827 p := x2.Args[0]
16828 idx := x2.Args[1]
16829 o0 := v.Args[1]
16830 if o0.Op != Op386ORL {
16831 break
16832 }
16833 _ = o0.Args[1]
16834 s0 := o0.Args[0]
16835 if s0.Op != Op386SHLLconst {
16836 break
16837 }
16838 if s0.AuxInt != 16 {
16839 break
16840 }
16841 x1 := s0.Args[0]
16842 if x1.Op != Op386MOVBloadidx1 {
16843 break
16844 }
16845 i2 := x1.AuxInt
16846 if x1.Aux != s {
16847 break
16848 }
16849 _ = x1.Args[2]
16850 if p != x1.Args[0] {
16851 break
16852 }
16853 if idx != x1.Args[1] {
16854 break
16855 }
16856 if mem != x1.Args[2] {
16857 break
16858 }
16859 x0 := o0.Args[1]
16860 if x0.Op != Op386MOVWloadidx1 {
16861 break
16862 }
16863 i0 := x0.AuxInt
16864 if x0.Aux != s {
16865 break
16866 }
16867 _ = x0.Args[2]
16868 if idx != x0.Args[0] {
16869 break
16870 }
16871 if p != x0.Args[1] {
16872 break
16873 }
16874 if mem != x0.Args[2] {
16875 break
16876 }
16877 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16878 break
16879 }
16880 b = mergePoint(b, x0, x1, x2)
16881 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16882 v.reset(OpCopy)
16883 v.AddArg(v0)
16884 v0.AuxInt = i0
16885 v0.Aux = s
16886 v0.AddArg(p)
16887 v0.AddArg(idx)
16888 v0.AddArg(mem)
16889 return true
16890 }
16891
16892
16893
16894 for {
16895 _ = v.Args[1]
16896 s1 := v.Args[0]
16897 if s1.Op != Op386SHLLconst {
16898 break
16899 }
16900 if s1.AuxInt != 24 {
16901 break
16902 }
16903 x2 := s1.Args[0]
16904 if x2.Op != Op386MOVBloadidx1 {
16905 break
16906 }
16907 i3 := x2.AuxInt
16908 s := x2.Aux
16909 mem := x2.Args[2]
16910 idx := x2.Args[0]
16911 p := x2.Args[1]
16912 o0 := v.Args[1]
16913 if o0.Op != Op386ORL {
16914 break
16915 }
16916 _ = o0.Args[1]
16917 s0 := o0.Args[0]
16918 if s0.Op != Op386SHLLconst {
16919 break
16920 }
16921 if s0.AuxInt != 16 {
16922 break
16923 }
16924 x1 := s0.Args[0]
16925 if x1.Op != Op386MOVBloadidx1 {
16926 break
16927 }
16928 i2 := x1.AuxInt
16929 if x1.Aux != s {
16930 break
16931 }
16932 _ = x1.Args[2]
16933 if p != x1.Args[0] {
16934 break
16935 }
16936 if idx != x1.Args[1] {
16937 break
16938 }
16939 if mem != x1.Args[2] {
16940 break
16941 }
16942 x0 := o0.Args[1]
16943 if x0.Op != Op386MOVWloadidx1 {
16944 break
16945 }
16946 i0 := x0.AuxInt
16947 if x0.Aux != s {
16948 break
16949 }
16950 _ = x0.Args[2]
16951 if idx != x0.Args[0] {
16952 break
16953 }
16954 if p != x0.Args[1] {
16955 break
16956 }
16957 if mem != x0.Args[2] {
16958 break
16959 }
16960 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
16961 break
16962 }
16963 b = mergePoint(b, x0, x1, x2)
16964 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
16965 v.reset(OpCopy)
16966 v.AddArg(v0)
16967 v0.AuxInt = i0
16968 v0.Aux = s
16969 v0.AddArg(p)
16970 v0.AddArg(idx)
16971 v0.AddArg(mem)
16972 return true
16973 }
16974
16975
16976
16977 for {
16978 _ = v.Args[1]
16979 s1 := v.Args[0]
16980 if s1.Op != Op386SHLLconst {
16981 break
16982 }
16983 if s1.AuxInt != 24 {
16984 break
16985 }
16986 x2 := s1.Args[0]
16987 if x2.Op != Op386MOVBloadidx1 {
16988 break
16989 }
16990 i3 := x2.AuxInt
16991 s := x2.Aux
16992 mem := x2.Args[2]
16993 p := x2.Args[0]
16994 idx := x2.Args[1]
16995 o0 := v.Args[1]
16996 if o0.Op != Op386ORL {
16997 break
16998 }
16999 _ = o0.Args[1]
17000 s0 := o0.Args[0]
17001 if s0.Op != Op386SHLLconst {
17002 break
17003 }
17004 if s0.AuxInt != 16 {
17005 break
17006 }
17007 x1 := s0.Args[0]
17008 if x1.Op != Op386MOVBloadidx1 {
17009 break
17010 }
17011 i2 := x1.AuxInt
17012 if x1.Aux != s {
17013 break
17014 }
17015 _ = x1.Args[2]
17016 if idx != x1.Args[0] {
17017 break
17018 }
17019 if p != x1.Args[1] {
17020 break
17021 }
17022 if mem != x1.Args[2] {
17023 break
17024 }
17025 x0 := o0.Args[1]
17026 if x0.Op != Op386MOVWloadidx1 {
17027 break
17028 }
17029 i0 := x0.AuxInt
17030 if x0.Aux != s {
17031 break
17032 }
17033 _ = x0.Args[2]
17034 if idx != x0.Args[0] {
17035 break
17036 }
17037 if p != x0.Args[1] {
17038 break
17039 }
17040 if mem != x0.Args[2] {
17041 break
17042 }
17043 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
17044 break
17045 }
17046 b = mergePoint(b, x0, x1, x2)
17047 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
17048 v.reset(OpCopy)
17049 v.AddArg(v0)
17050 v0.AuxInt = i0
17051 v0.Aux = s
17052 v0.AddArg(p)
17053 v0.AddArg(idx)
17054 v0.AddArg(mem)
17055 return true
17056 }
17057
17058
17059
17060 for {
17061 _ = v.Args[1]
17062 s1 := v.Args[0]
17063 if s1.Op != Op386SHLLconst {
17064 break
17065 }
17066 if s1.AuxInt != 24 {
17067 break
17068 }
17069 x2 := s1.Args[0]
17070 if x2.Op != Op386MOVBloadidx1 {
17071 break
17072 }
17073 i3 := x2.AuxInt
17074 s := x2.Aux
17075 mem := x2.Args[2]
17076 idx := x2.Args[0]
17077 p := x2.Args[1]
17078 o0 := v.Args[1]
17079 if o0.Op != Op386ORL {
17080 break
17081 }
17082 _ = o0.Args[1]
17083 s0 := o0.Args[0]
17084 if s0.Op != Op386SHLLconst {
17085 break
17086 }
17087 if s0.AuxInt != 16 {
17088 break
17089 }
17090 x1 := s0.Args[0]
17091 if x1.Op != Op386MOVBloadidx1 {
17092 break
17093 }
17094 i2 := x1.AuxInt
17095 if x1.Aux != s {
17096 break
17097 }
17098 _ = x1.Args[2]
17099 if idx != x1.Args[0] {
17100 break
17101 }
17102 if p != x1.Args[1] {
17103 break
17104 }
17105 if mem != x1.Args[2] {
17106 break
17107 }
17108 x0 := o0.Args[1]
17109 if x0.Op != Op386MOVWloadidx1 {
17110 break
17111 }
17112 i0 := x0.AuxInt
17113 if x0.Aux != s {
17114 break
17115 }
17116 _ = x0.Args[2]
17117 if idx != x0.Args[0] {
17118 break
17119 }
17120 if p != x0.Args[1] {
17121 break
17122 }
17123 if mem != x0.Args[2] {
17124 break
17125 }
17126 if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
17127 break
17128 }
17129 b = mergePoint(b, x0, x1, x2)
17130 v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
17131 v.reset(OpCopy)
17132 v.AddArg(v0)
17133 v0.AuxInt = i0
17134 v0.Aux = s
17135 v0.AddArg(p)
17136 v0.AddArg(idx)
17137 v0.AddArg(mem)
17138 return true
17139 }
17140 return false
17141 }
17142 func rewriteValue386_Op386ORLconst_0(v *Value) bool {
17143
17144
17145
17146 for {
17147 c := v.AuxInt
17148 x := v.Args[0]
17149 if !(int32(c) == 0) {
17150 break
17151 }
17152 v.reset(OpCopy)
17153 v.Type = x.Type
17154 v.AddArg(x)
17155 return true
17156 }
17157
17158
17159
17160 for {
17161 c := v.AuxInt
17162 if !(int32(c) == -1) {
17163 break
17164 }
17165 v.reset(Op386MOVLconst)
17166 v.AuxInt = -1
17167 return true
17168 }
17169
17170
17171
17172 for {
17173 c := v.AuxInt
17174 v_0 := v.Args[0]
17175 if v_0.Op != Op386MOVLconst {
17176 break
17177 }
17178 d := v_0.AuxInt
17179 v.reset(Op386MOVLconst)
17180 v.AuxInt = c | d
17181 return true
17182 }
17183 return false
17184 }
17185 func rewriteValue386_Op386ORLconstmodify_0(v *Value) bool {
17186 b := v.Block
17187 config := b.Func.Config
17188
17189
17190
17191 for {
17192 valoff1 := v.AuxInt
17193 sym := v.Aux
17194 mem := v.Args[1]
17195 v_0 := v.Args[0]
17196 if v_0.Op != Op386ADDLconst {
17197 break
17198 }
17199 off2 := v_0.AuxInt
17200 base := v_0.Args[0]
17201 if !(ValAndOff(valoff1).canAdd(off2)) {
17202 break
17203 }
17204 v.reset(Op386ORLconstmodify)
17205 v.AuxInt = ValAndOff(valoff1).add(off2)
17206 v.Aux = sym
17207 v.AddArg(base)
17208 v.AddArg(mem)
17209 return true
17210 }
17211
17212
17213
17214 for {
17215 valoff1 := v.AuxInt
17216 sym1 := v.Aux
17217 mem := v.Args[1]
17218 v_0 := v.Args[0]
17219 if v_0.Op != Op386LEAL {
17220 break
17221 }
17222 off2 := v_0.AuxInt
17223 sym2 := v_0.Aux
17224 base := v_0.Args[0]
17225 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
17226 break
17227 }
17228 v.reset(Op386ORLconstmodify)
17229 v.AuxInt = ValAndOff(valoff1).add(off2)
17230 v.Aux = mergeSym(sym1, sym2)
17231 v.AddArg(base)
17232 v.AddArg(mem)
17233 return true
17234 }
17235 return false
17236 }
17237 func rewriteValue386_Op386ORLconstmodifyidx4_0(v *Value) bool {
17238 b := v.Block
17239 config := b.Func.Config
17240
17241
17242
17243 for {
17244 valoff1 := v.AuxInt
17245 sym := v.Aux
17246 mem := v.Args[2]
17247 v_0 := v.Args[0]
17248 if v_0.Op != Op386ADDLconst {
17249 break
17250 }
17251 off2 := v_0.AuxInt
17252 base := v_0.Args[0]
17253 idx := v.Args[1]
17254 if !(ValAndOff(valoff1).canAdd(off2)) {
17255 break
17256 }
17257 v.reset(Op386ORLconstmodifyidx4)
17258 v.AuxInt = ValAndOff(valoff1).add(off2)
17259 v.Aux = sym
17260 v.AddArg(base)
17261 v.AddArg(idx)
17262 v.AddArg(mem)
17263 return true
17264 }
17265
17266
17267
17268 for {
17269 valoff1 := v.AuxInt
17270 sym := v.Aux
17271 mem := v.Args[2]
17272 base := v.Args[0]
17273 v_1 := v.Args[1]
17274 if v_1.Op != Op386ADDLconst {
17275 break
17276 }
17277 off2 := v_1.AuxInt
17278 idx := v_1.Args[0]
17279 if !(ValAndOff(valoff1).canAdd(off2 * 4)) {
17280 break
17281 }
17282 v.reset(Op386ORLconstmodifyidx4)
17283 v.AuxInt = ValAndOff(valoff1).add(off2 * 4)
17284 v.Aux = sym
17285 v.AddArg(base)
17286 v.AddArg(idx)
17287 v.AddArg(mem)
17288 return true
17289 }
17290
17291
17292
17293 for {
17294 valoff1 := v.AuxInt
17295 sym1 := v.Aux
17296 mem := v.Args[2]
17297 v_0 := v.Args[0]
17298 if v_0.Op != Op386LEAL {
17299 break
17300 }
17301 off2 := v_0.AuxInt
17302 sym2 := v_0.Aux
17303 base := v_0.Args[0]
17304 idx := v.Args[1]
17305 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
17306 break
17307 }
17308 v.reset(Op386ORLconstmodifyidx4)
17309 v.AuxInt = ValAndOff(valoff1).add(off2)
17310 v.Aux = mergeSym(sym1, sym2)
17311 v.AddArg(base)
17312 v.AddArg(idx)
17313 v.AddArg(mem)
17314 return true
17315 }
17316 return false
17317 }
17318 func rewriteValue386_Op386ORLload_0(v *Value) bool {
17319 b := v.Block
17320 config := b.Func.Config
17321
17322
17323
17324 for {
17325 off1 := v.AuxInt
17326 sym := v.Aux
17327 mem := v.Args[2]
17328 val := v.Args[0]
17329 v_1 := v.Args[1]
17330 if v_1.Op != Op386ADDLconst {
17331 break
17332 }
17333 off2 := v_1.AuxInt
17334 base := v_1.Args[0]
17335 if !(is32Bit(off1 + off2)) {
17336 break
17337 }
17338 v.reset(Op386ORLload)
17339 v.AuxInt = off1 + off2
17340 v.Aux = sym
17341 v.AddArg(val)
17342 v.AddArg(base)
17343 v.AddArg(mem)
17344 return true
17345 }
17346
17347
17348
17349 for {
17350 off1 := v.AuxInt
17351 sym1 := v.Aux
17352 mem := v.Args[2]
17353 val := v.Args[0]
17354 v_1 := v.Args[1]
17355 if v_1.Op != Op386LEAL {
17356 break
17357 }
17358 off2 := v_1.AuxInt
17359 sym2 := v_1.Aux
17360 base := v_1.Args[0]
17361 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
17362 break
17363 }
17364 v.reset(Op386ORLload)
17365 v.AuxInt = off1 + off2
17366 v.Aux = mergeSym(sym1, sym2)
17367 v.AddArg(val)
17368 v.AddArg(base)
17369 v.AddArg(mem)
17370 return true
17371 }
17372
17373
17374
17375 for {
17376 off1 := v.AuxInt
17377 sym1 := v.Aux
17378 mem := v.Args[2]
17379 val := v.Args[0]
17380 v_1 := v.Args[1]
17381 if v_1.Op != Op386LEAL4 {
17382 break
17383 }
17384 off2 := v_1.AuxInt
17385 sym2 := v_1.Aux
17386 idx := v_1.Args[1]
17387 ptr := v_1.Args[0]
17388 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
17389 break
17390 }
17391 v.reset(Op386ORLloadidx4)
17392 v.AuxInt = off1 + off2
17393 v.Aux = mergeSym(sym1, sym2)
17394 v.AddArg(val)
17395 v.AddArg(ptr)
17396 v.AddArg(idx)
17397 v.AddArg(mem)
17398 return true
17399 }
17400 return false
17401 }
17402 func rewriteValue386_Op386ORLloadidx4_0(v *Value) bool {
17403 b := v.Block
17404 config := b.Func.Config
17405
17406
17407
17408 for {
17409 off1 := v.AuxInt
17410 sym := v.Aux
17411 mem := v.Args[3]
17412 val := v.Args[0]
17413 v_1 := v.Args[1]
17414 if v_1.Op != Op386ADDLconst {
17415 break
17416 }
17417 off2 := v_1.AuxInt
17418 base := v_1.Args[0]
17419 idx := v.Args[2]
17420 if !(is32Bit(off1 + off2)) {
17421 break
17422 }
17423 v.reset(Op386ORLloadidx4)
17424 v.AuxInt = off1 + off2
17425 v.Aux = sym
17426 v.AddArg(val)
17427 v.AddArg(base)
17428 v.AddArg(idx)
17429 v.AddArg(mem)
17430 return true
17431 }
17432
17433
17434
17435 for {
17436 off1 := v.AuxInt
17437 sym := v.Aux
17438 mem := v.Args[3]
17439 val := v.Args[0]
17440 base := v.Args[1]
17441 v_2 := v.Args[2]
17442 if v_2.Op != Op386ADDLconst {
17443 break
17444 }
17445 off2 := v_2.AuxInt
17446 idx := v_2.Args[0]
17447 if !(is32Bit(off1 + off2*4)) {
17448 break
17449 }
17450 v.reset(Op386ORLloadidx4)
17451 v.AuxInt = off1 + off2*4
17452 v.Aux = sym
17453 v.AddArg(val)
17454 v.AddArg(base)
17455 v.AddArg(idx)
17456 v.AddArg(mem)
17457 return true
17458 }
17459
17460
17461
17462 for {
17463 off1 := v.AuxInt
17464 sym1 := v.Aux
17465 mem := v.Args[3]
17466 val := v.Args[0]
17467 v_1 := v.Args[1]
17468 if v_1.Op != Op386LEAL {
17469 break
17470 }
17471 off2 := v_1.AuxInt
17472 sym2 := v_1.Aux
17473 base := v_1.Args[0]
17474 idx := v.Args[2]
17475 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
17476 break
17477 }
17478 v.reset(Op386ORLloadidx4)
17479 v.AuxInt = off1 + off2
17480 v.Aux = mergeSym(sym1, sym2)
17481 v.AddArg(val)
17482 v.AddArg(base)
17483 v.AddArg(idx)
17484 v.AddArg(mem)
17485 return true
17486 }
17487 return false
17488 }
17489 func rewriteValue386_Op386ORLmodify_0(v *Value) bool {
17490 b := v.Block
17491 config := b.Func.Config
17492
17493
17494
17495 for {
17496 off1 := v.AuxInt
17497 sym := v.Aux
17498 mem := v.Args[2]
17499 v_0 := v.Args[0]
17500 if v_0.Op != Op386ADDLconst {
17501 break
17502 }
17503 off2 := v_0.AuxInt
17504 base := v_0.Args[0]
17505 val := v.Args[1]
17506 if !(is32Bit(off1 + off2)) {
17507 break
17508 }
17509 v.reset(Op386ORLmodify)
17510 v.AuxInt = off1 + off2
17511 v.Aux = sym
17512 v.AddArg(base)
17513 v.AddArg(val)
17514 v.AddArg(mem)
17515 return true
17516 }
17517
17518
17519
17520 for {
17521 off1 := v.AuxInt
17522 sym1 := v.Aux
17523 mem := v.Args[2]
17524 v_0 := v.Args[0]
17525 if v_0.Op != Op386LEAL {
17526 break
17527 }
17528 off2 := v_0.AuxInt
17529 sym2 := v_0.Aux
17530 base := v_0.Args[0]
17531 val := v.Args[1]
17532 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
17533 break
17534 }
17535 v.reset(Op386ORLmodify)
17536 v.AuxInt = off1 + off2
17537 v.Aux = mergeSym(sym1, sym2)
17538 v.AddArg(base)
17539 v.AddArg(val)
17540 v.AddArg(mem)
17541 return true
17542 }
17543 return false
17544 }
17545 func rewriteValue386_Op386ORLmodifyidx4_0(v *Value) bool {
17546 b := v.Block
17547 config := b.Func.Config
17548
17549
17550
17551 for {
17552 off1 := v.AuxInt
17553 sym := v.Aux
17554 mem := v.Args[3]
17555 v_0 := v.Args[0]
17556 if v_0.Op != Op386ADDLconst {
17557 break
17558 }
17559 off2 := v_0.AuxInt
17560 base := v_0.Args[0]
17561 idx := v.Args[1]
17562 val := v.Args[2]
17563 if !(is32Bit(off1 + off2)) {
17564 break
17565 }
17566 v.reset(Op386ORLmodifyidx4)
17567 v.AuxInt = off1 + off2
17568 v.Aux = sym
17569 v.AddArg(base)
17570 v.AddArg(idx)
17571 v.AddArg(val)
17572 v.AddArg(mem)
17573 return true
17574 }
17575
17576
17577
17578 for {
17579 off1 := v.AuxInt
17580 sym := v.Aux
17581 mem := v.Args[3]
17582 base := v.Args[0]
17583 v_1 := v.Args[1]
17584 if v_1.Op != Op386ADDLconst {
17585 break
17586 }
17587 off2 := v_1.AuxInt
17588 idx := v_1.Args[0]
17589 val := v.Args[2]
17590 if !(is32Bit(off1 + off2*4)) {
17591 break
17592 }
17593 v.reset(Op386ORLmodifyidx4)
17594 v.AuxInt = off1 + off2*4
17595 v.Aux = sym
17596 v.AddArg(base)
17597 v.AddArg(idx)
17598 v.AddArg(val)
17599 v.AddArg(mem)
17600 return true
17601 }
17602
17603
17604
17605 for {
17606 off1 := v.AuxInt
17607 sym1 := v.Aux
17608 mem := v.Args[3]
17609 v_0 := v.Args[0]
17610 if v_0.Op != Op386LEAL {
17611 break
17612 }
17613 off2 := v_0.AuxInt
17614 sym2 := v_0.Aux
17615 base := v_0.Args[0]
17616 idx := v.Args[1]
17617 val := v.Args[2]
17618 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
17619 break
17620 }
17621 v.reset(Op386ORLmodifyidx4)
17622 v.AuxInt = off1 + off2
17623 v.Aux = mergeSym(sym1, sym2)
17624 v.AddArg(base)
17625 v.AddArg(idx)
17626 v.AddArg(val)
17627 v.AddArg(mem)
17628 return true
17629 }
17630
17631
17632
17633 for {
17634 off := v.AuxInt
17635 sym := v.Aux
17636 mem := v.Args[3]
17637 ptr := v.Args[0]
17638 idx := v.Args[1]
17639 v_2 := v.Args[2]
17640 if v_2.Op != Op386MOVLconst {
17641 break
17642 }
17643 c := v_2.AuxInt
17644 if !(validValAndOff(c, off)) {
17645 break
17646 }
17647 v.reset(Op386ORLconstmodifyidx4)
17648 v.AuxInt = makeValAndOff(c, off)
17649 v.Aux = sym
17650 v.AddArg(ptr)
17651 v.AddArg(idx)
17652 v.AddArg(mem)
17653 return true
17654 }
17655 return false
17656 }
17657 func rewriteValue386_Op386ROLBconst_0(v *Value) bool {
17658
17659
17660
17661 for {
17662 c := v.AuxInt
17663 v_0 := v.Args[0]
17664 if v_0.Op != Op386ROLBconst {
17665 break
17666 }
17667 d := v_0.AuxInt
17668 x := v_0.Args[0]
17669 v.reset(Op386ROLBconst)
17670 v.AuxInt = (c + d) & 7
17671 v.AddArg(x)
17672 return true
17673 }
17674
17675
17676
17677 for {
17678 if v.AuxInt != 0 {
17679 break
17680 }
17681 x := v.Args[0]
17682 v.reset(OpCopy)
17683 v.Type = x.Type
17684 v.AddArg(x)
17685 return true
17686 }
17687 return false
17688 }
17689 func rewriteValue386_Op386ROLLconst_0(v *Value) bool {
17690
17691
17692
17693 for {
17694 c := v.AuxInt
17695 v_0 := v.Args[0]
17696 if v_0.Op != Op386ROLLconst {
17697 break
17698 }
17699 d := v_0.AuxInt
17700 x := v_0.Args[0]
17701 v.reset(Op386ROLLconst)
17702 v.AuxInt = (c + d) & 31
17703 v.AddArg(x)
17704 return true
17705 }
17706
17707
17708
17709 for {
17710 if v.AuxInt != 0 {
17711 break
17712 }
17713 x := v.Args[0]
17714 v.reset(OpCopy)
17715 v.Type = x.Type
17716 v.AddArg(x)
17717 return true
17718 }
17719 return false
17720 }
17721 func rewriteValue386_Op386ROLWconst_0(v *Value) bool {
17722
17723
17724
17725 for {
17726 c := v.AuxInt
17727 v_0 := v.Args[0]
17728 if v_0.Op != Op386ROLWconst {
17729 break
17730 }
17731 d := v_0.AuxInt
17732 x := v_0.Args[0]
17733 v.reset(Op386ROLWconst)
17734 v.AuxInt = (c + d) & 15
17735 v.AddArg(x)
17736 return true
17737 }
17738
17739
17740
17741 for {
17742 if v.AuxInt != 0 {
17743 break
17744 }
17745 x := v.Args[0]
17746 v.reset(OpCopy)
17747 v.Type = x.Type
17748 v.AddArg(x)
17749 return true
17750 }
17751 return false
17752 }
17753 func rewriteValue386_Op386SARB_0(v *Value) bool {
17754
17755
17756
17757 for {
17758 _ = v.Args[1]
17759 x := v.Args[0]
17760 v_1 := v.Args[1]
17761 if v_1.Op != Op386MOVLconst {
17762 break
17763 }
17764 c := v_1.AuxInt
17765 v.reset(Op386SARBconst)
17766 v.AuxInt = min(c&31, 7)
17767 v.AddArg(x)
17768 return true
17769 }
17770 return false
17771 }
17772 func rewriteValue386_Op386SARBconst_0(v *Value) bool {
17773
17774
17775
17776 for {
17777 if v.AuxInt != 0 {
17778 break
17779 }
17780 x := v.Args[0]
17781 v.reset(OpCopy)
17782 v.Type = x.Type
17783 v.AddArg(x)
17784 return true
17785 }
17786
17787
17788
17789 for {
17790 c := v.AuxInt
17791 v_0 := v.Args[0]
17792 if v_0.Op != Op386MOVLconst {
17793 break
17794 }
17795 d := v_0.AuxInt
17796 v.reset(Op386MOVLconst)
17797 v.AuxInt = d >> uint64(c)
17798 return true
17799 }
17800 return false
17801 }
17802 func rewriteValue386_Op386SARL_0(v *Value) bool {
17803
17804
17805
17806 for {
17807 _ = v.Args[1]
17808 x := v.Args[0]
17809 v_1 := v.Args[1]
17810 if v_1.Op != Op386MOVLconst {
17811 break
17812 }
17813 c := v_1.AuxInt
17814 v.reset(Op386SARLconst)
17815 v.AuxInt = c & 31
17816 v.AddArg(x)
17817 return true
17818 }
17819
17820
17821
17822 for {
17823 _ = v.Args[1]
17824 x := v.Args[0]
17825 v_1 := v.Args[1]
17826 if v_1.Op != Op386ANDLconst {
17827 break
17828 }
17829 if v_1.AuxInt != 31 {
17830 break
17831 }
17832 y := v_1.Args[0]
17833 v.reset(Op386SARL)
17834 v.AddArg(x)
17835 v.AddArg(y)
17836 return true
17837 }
17838 return false
17839 }
17840 func rewriteValue386_Op386SARLconst_0(v *Value) bool {
17841
17842
17843
17844 for {
17845 if v.AuxInt != 0 {
17846 break
17847 }
17848 x := v.Args[0]
17849 v.reset(OpCopy)
17850 v.Type = x.Type
17851 v.AddArg(x)
17852 return true
17853 }
17854
17855
17856
17857 for {
17858 c := v.AuxInt
17859 v_0 := v.Args[0]
17860 if v_0.Op != Op386MOVLconst {
17861 break
17862 }
17863 d := v_0.AuxInt
17864 v.reset(Op386MOVLconst)
17865 v.AuxInt = d >> uint64(c)
17866 return true
17867 }
17868 return false
17869 }
17870 func rewriteValue386_Op386SARW_0(v *Value) bool {
17871
17872
17873
17874 for {
17875 _ = v.Args[1]
17876 x := v.Args[0]
17877 v_1 := v.Args[1]
17878 if v_1.Op != Op386MOVLconst {
17879 break
17880 }
17881 c := v_1.AuxInt
17882 v.reset(Op386SARWconst)
17883 v.AuxInt = min(c&31, 15)
17884 v.AddArg(x)
17885 return true
17886 }
17887 return false
17888 }
17889 func rewriteValue386_Op386SARWconst_0(v *Value) bool {
17890
17891
17892
17893 for {
17894 if v.AuxInt != 0 {
17895 break
17896 }
17897 x := v.Args[0]
17898 v.reset(OpCopy)
17899 v.Type = x.Type
17900 v.AddArg(x)
17901 return true
17902 }
17903
17904
17905
17906 for {
17907 c := v.AuxInt
17908 v_0 := v.Args[0]
17909 if v_0.Op != Op386MOVLconst {
17910 break
17911 }
17912 d := v_0.AuxInt
17913 v.reset(Op386MOVLconst)
17914 v.AuxInt = d >> uint64(c)
17915 return true
17916 }
17917 return false
17918 }
17919 func rewriteValue386_Op386SBBL_0(v *Value) bool {
17920
17921
17922
17923 for {
17924 f := v.Args[2]
17925 x := v.Args[0]
17926 v_1 := v.Args[1]
17927 if v_1.Op != Op386MOVLconst {
17928 break
17929 }
17930 c := v_1.AuxInt
17931 v.reset(Op386SBBLconst)
17932 v.AuxInt = c
17933 v.AddArg(x)
17934 v.AddArg(f)
17935 return true
17936 }
17937 return false
17938 }
17939 func rewriteValue386_Op386SBBLcarrymask_0(v *Value) bool {
17940
17941
17942
17943 for {
17944 v_0 := v.Args[0]
17945 if v_0.Op != Op386FlagEQ {
17946 break
17947 }
17948 v.reset(Op386MOVLconst)
17949 v.AuxInt = 0
17950 return true
17951 }
17952
17953
17954
17955 for {
17956 v_0 := v.Args[0]
17957 if v_0.Op != Op386FlagLT_ULT {
17958 break
17959 }
17960 v.reset(Op386MOVLconst)
17961 v.AuxInt = -1
17962 return true
17963 }
17964
17965
17966
17967 for {
17968 v_0 := v.Args[0]
17969 if v_0.Op != Op386FlagLT_UGT {
17970 break
17971 }
17972 v.reset(Op386MOVLconst)
17973 v.AuxInt = 0
17974 return true
17975 }
17976
17977
17978
17979 for {
17980 v_0 := v.Args[0]
17981 if v_0.Op != Op386FlagGT_ULT {
17982 break
17983 }
17984 v.reset(Op386MOVLconst)
17985 v.AuxInt = -1
17986 return true
17987 }
17988
17989
17990
17991 for {
17992 v_0 := v.Args[0]
17993 if v_0.Op != Op386FlagGT_UGT {
17994 break
17995 }
17996 v.reset(Op386MOVLconst)
17997 v.AuxInt = 0
17998 return true
17999 }
18000 return false
18001 }
18002 func rewriteValue386_Op386SETA_0(v *Value) bool {
18003
18004
18005
18006 for {
18007 v_0 := v.Args[0]
18008 if v_0.Op != Op386InvertFlags {
18009 break
18010 }
18011 x := v_0.Args[0]
18012 v.reset(Op386SETB)
18013 v.AddArg(x)
18014 return true
18015 }
18016
18017
18018
18019 for {
18020 v_0 := v.Args[0]
18021 if v_0.Op != Op386FlagEQ {
18022 break
18023 }
18024 v.reset(Op386MOVLconst)
18025 v.AuxInt = 0
18026 return true
18027 }
18028
18029
18030
18031 for {
18032 v_0 := v.Args[0]
18033 if v_0.Op != Op386FlagLT_ULT {
18034 break
18035 }
18036 v.reset(Op386MOVLconst)
18037 v.AuxInt = 0
18038 return true
18039 }
18040
18041
18042
18043 for {
18044 v_0 := v.Args[0]
18045 if v_0.Op != Op386FlagLT_UGT {
18046 break
18047 }
18048 v.reset(Op386MOVLconst)
18049 v.AuxInt = 1
18050 return true
18051 }
18052
18053
18054
18055 for {
18056 v_0 := v.Args[0]
18057 if v_0.Op != Op386FlagGT_ULT {
18058 break
18059 }
18060 v.reset(Op386MOVLconst)
18061 v.AuxInt = 0
18062 return true
18063 }
18064
18065
18066
18067 for {
18068 v_0 := v.Args[0]
18069 if v_0.Op != Op386FlagGT_UGT {
18070 break
18071 }
18072 v.reset(Op386MOVLconst)
18073 v.AuxInt = 1
18074 return true
18075 }
18076 return false
18077 }
18078 func rewriteValue386_Op386SETAE_0(v *Value) bool {
18079
18080
18081
18082 for {
18083 v_0 := v.Args[0]
18084 if v_0.Op != Op386InvertFlags {
18085 break
18086 }
18087 x := v_0.Args[0]
18088 v.reset(Op386SETBE)
18089 v.AddArg(x)
18090 return true
18091 }
18092
18093
18094
18095 for {
18096 v_0 := v.Args[0]
18097 if v_0.Op != Op386FlagEQ {
18098 break
18099 }
18100 v.reset(Op386MOVLconst)
18101 v.AuxInt = 1
18102 return true
18103 }
18104
18105
18106
18107 for {
18108 v_0 := v.Args[0]
18109 if v_0.Op != Op386FlagLT_ULT {
18110 break
18111 }
18112 v.reset(Op386MOVLconst)
18113 v.AuxInt = 0
18114 return true
18115 }
18116
18117
18118
18119 for {
18120 v_0 := v.Args[0]
18121 if v_0.Op != Op386FlagLT_UGT {
18122 break
18123 }
18124 v.reset(Op386MOVLconst)
18125 v.AuxInt = 1
18126 return true
18127 }
18128
18129
18130
18131 for {
18132 v_0 := v.Args[0]
18133 if v_0.Op != Op386FlagGT_ULT {
18134 break
18135 }
18136 v.reset(Op386MOVLconst)
18137 v.AuxInt = 0
18138 return true
18139 }
18140
18141
18142
18143 for {
18144 v_0 := v.Args[0]
18145 if v_0.Op != Op386FlagGT_UGT {
18146 break
18147 }
18148 v.reset(Op386MOVLconst)
18149 v.AuxInt = 1
18150 return true
18151 }
18152 return false
18153 }
18154 func rewriteValue386_Op386SETB_0(v *Value) bool {
18155
18156
18157
18158 for {
18159 v_0 := v.Args[0]
18160 if v_0.Op != Op386InvertFlags {
18161 break
18162 }
18163 x := v_0.Args[0]
18164 v.reset(Op386SETA)
18165 v.AddArg(x)
18166 return true
18167 }
18168
18169
18170
18171 for {
18172 v_0 := v.Args[0]
18173 if v_0.Op != Op386FlagEQ {
18174 break
18175 }
18176 v.reset(Op386MOVLconst)
18177 v.AuxInt = 0
18178 return true
18179 }
18180
18181
18182
18183 for {
18184 v_0 := v.Args[0]
18185 if v_0.Op != Op386FlagLT_ULT {
18186 break
18187 }
18188 v.reset(Op386MOVLconst)
18189 v.AuxInt = 1
18190 return true
18191 }
18192
18193
18194
18195 for {
18196 v_0 := v.Args[0]
18197 if v_0.Op != Op386FlagLT_UGT {
18198 break
18199 }
18200 v.reset(Op386MOVLconst)
18201 v.AuxInt = 0
18202 return true
18203 }
18204
18205
18206
18207 for {
18208 v_0 := v.Args[0]
18209 if v_0.Op != Op386FlagGT_ULT {
18210 break
18211 }
18212 v.reset(Op386MOVLconst)
18213 v.AuxInt = 1
18214 return true
18215 }
18216
18217
18218
18219 for {
18220 v_0 := v.Args[0]
18221 if v_0.Op != Op386FlagGT_UGT {
18222 break
18223 }
18224 v.reset(Op386MOVLconst)
18225 v.AuxInt = 0
18226 return true
18227 }
18228 return false
18229 }
18230 func rewriteValue386_Op386SETBE_0(v *Value) bool {
18231
18232
18233
18234 for {
18235 v_0 := v.Args[0]
18236 if v_0.Op != Op386InvertFlags {
18237 break
18238 }
18239 x := v_0.Args[0]
18240 v.reset(Op386SETAE)
18241 v.AddArg(x)
18242 return true
18243 }
18244
18245
18246
18247 for {
18248 v_0 := v.Args[0]
18249 if v_0.Op != Op386FlagEQ {
18250 break
18251 }
18252 v.reset(Op386MOVLconst)
18253 v.AuxInt = 1
18254 return true
18255 }
18256
18257
18258
18259 for {
18260 v_0 := v.Args[0]
18261 if v_0.Op != Op386FlagLT_ULT {
18262 break
18263 }
18264 v.reset(Op386MOVLconst)
18265 v.AuxInt = 1
18266 return true
18267 }
18268
18269
18270
18271 for {
18272 v_0 := v.Args[0]
18273 if v_0.Op != Op386FlagLT_UGT {
18274 break
18275 }
18276 v.reset(Op386MOVLconst)
18277 v.AuxInt = 0
18278 return true
18279 }
18280
18281
18282
18283 for {
18284 v_0 := v.Args[0]
18285 if v_0.Op != Op386FlagGT_ULT {
18286 break
18287 }
18288 v.reset(Op386MOVLconst)
18289 v.AuxInt = 1
18290 return true
18291 }
18292
18293
18294
18295 for {
18296 v_0 := v.Args[0]
18297 if v_0.Op != Op386FlagGT_UGT {
18298 break
18299 }
18300 v.reset(Op386MOVLconst)
18301 v.AuxInt = 0
18302 return true
18303 }
18304 return false
18305 }
18306 func rewriteValue386_Op386SETEQ_0(v *Value) bool {
18307
18308
18309
18310 for {
18311 v_0 := v.Args[0]
18312 if v_0.Op != Op386InvertFlags {
18313 break
18314 }
18315 x := v_0.Args[0]
18316 v.reset(Op386SETEQ)
18317 v.AddArg(x)
18318 return true
18319 }
18320
18321
18322
18323 for {
18324 v_0 := v.Args[0]
18325 if v_0.Op != Op386FlagEQ {
18326 break
18327 }
18328 v.reset(Op386MOVLconst)
18329 v.AuxInt = 1
18330 return true
18331 }
18332
18333
18334
18335 for {
18336 v_0 := v.Args[0]
18337 if v_0.Op != Op386FlagLT_ULT {
18338 break
18339 }
18340 v.reset(Op386MOVLconst)
18341 v.AuxInt = 0
18342 return true
18343 }
18344
18345
18346
18347 for {
18348 v_0 := v.Args[0]
18349 if v_0.Op != Op386FlagLT_UGT {
18350 break
18351 }
18352 v.reset(Op386MOVLconst)
18353 v.AuxInt = 0
18354 return true
18355 }
18356
18357
18358
18359 for {
18360 v_0 := v.Args[0]
18361 if v_0.Op != Op386FlagGT_ULT {
18362 break
18363 }
18364 v.reset(Op386MOVLconst)
18365 v.AuxInt = 0
18366 return true
18367 }
18368
18369
18370
18371 for {
18372 v_0 := v.Args[0]
18373 if v_0.Op != Op386FlagGT_UGT {
18374 break
18375 }
18376 v.reset(Op386MOVLconst)
18377 v.AuxInt = 0
18378 return true
18379 }
18380 return false
18381 }
18382 func rewriteValue386_Op386SETG_0(v *Value) bool {
18383
18384
18385
18386 for {
18387 v_0 := v.Args[0]
18388 if v_0.Op != Op386InvertFlags {
18389 break
18390 }
18391 x := v_0.Args[0]
18392 v.reset(Op386SETL)
18393 v.AddArg(x)
18394 return true
18395 }
18396
18397
18398
18399 for {
18400 v_0 := v.Args[0]
18401 if v_0.Op != Op386FlagEQ {
18402 break
18403 }
18404 v.reset(Op386MOVLconst)
18405 v.AuxInt = 0
18406 return true
18407 }
18408
18409
18410
18411 for {
18412 v_0 := v.Args[0]
18413 if v_0.Op != Op386FlagLT_ULT {
18414 break
18415 }
18416 v.reset(Op386MOVLconst)
18417 v.AuxInt = 0
18418 return true
18419 }
18420
18421
18422
18423 for {
18424 v_0 := v.Args[0]
18425 if v_0.Op != Op386FlagLT_UGT {
18426 break
18427 }
18428 v.reset(Op386MOVLconst)
18429 v.AuxInt = 0
18430 return true
18431 }
18432
18433
18434
18435 for {
18436 v_0 := v.Args[0]
18437 if v_0.Op != Op386FlagGT_ULT {
18438 break
18439 }
18440 v.reset(Op386MOVLconst)
18441 v.AuxInt = 1
18442 return true
18443 }
18444
18445
18446
18447 for {
18448 v_0 := v.Args[0]
18449 if v_0.Op != Op386FlagGT_UGT {
18450 break
18451 }
18452 v.reset(Op386MOVLconst)
18453 v.AuxInt = 1
18454 return true
18455 }
18456 return false
18457 }
18458 func rewriteValue386_Op386SETGE_0(v *Value) bool {
18459
18460
18461
18462 for {
18463 v_0 := v.Args[0]
18464 if v_0.Op != Op386InvertFlags {
18465 break
18466 }
18467 x := v_0.Args[0]
18468 v.reset(Op386SETLE)
18469 v.AddArg(x)
18470 return true
18471 }
18472
18473
18474
18475 for {
18476 v_0 := v.Args[0]
18477 if v_0.Op != Op386FlagEQ {
18478 break
18479 }
18480 v.reset(Op386MOVLconst)
18481 v.AuxInt = 1
18482 return true
18483 }
18484
18485
18486
18487 for {
18488 v_0 := v.Args[0]
18489 if v_0.Op != Op386FlagLT_ULT {
18490 break
18491 }
18492 v.reset(Op386MOVLconst)
18493 v.AuxInt = 0
18494 return true
18495 }
18496
18497
18498
18499 for {
18500 v_0 := v.Args[0]
18501 if v_0.Op != Op386FlagLT_UGT {
18502 break
18503 }
18504 v.reset(Op386MOVLconst)
18505 v.AuxInt = 0
18506 return true
18507 }
18508
18509
18510
18511 for {
18512 v_0 := v.Args[0]
18513 if v_0.Op != Op386FlagGT_ULT {
18514 break
18515 }
18516 v.reset(Op386MOVLconst)
18517 v.AuxInt = 1
18518 return true
18519 }
18520
18521
18522
18523 for {
18524 v_0 := v.Args[0]
18525 if v_0.Op != Op386FlagGT_UGT {
18526 break
18527 }
18528 v.reset(Op386MOVLconst)
18529 v.AuxInt = 1
18530 return true
18531 }
18532 return false
18533 }
18534 func rewriteValue386_Op386SETL_0(v *Value) bool {
18535
18536
18537
18538 for {
18539 v_0 := v.Args[0]
18540 if v_0.Op != Op386InvertFlags {
18541 break
18542 }
18543 x := v_0.Args[0]
18544 v.reset(Op386SETG)
18545 v.AddArg(x)
18546 return true
18547 }
18548
18549
18550
18551 for {
18552 v_0 := v.Args[0]
18553 if v_0.Op != Op386FlagEQ {
18554 break
18555 }
18556 v.reset(Op386MOVLconst)
18557 v.AuxInt = 0
18558 return true
18559 }
18560
18561
18562
18563 for {
18564 v_0 := v.Args[0]
18565 if v_0.Op != Op386FlagLT_ULT {
18566 break
18567 }
18568 v.reset(Op386MOVLconst)
18569 v.AuxInt = 1
18570 return true
18571 }
18572
18573
18574
18575 for {
18576 v_0 := v.Args[0]
18577 if v_0.Op != Op386FlagLT_UGT {
18578 break
18579 }
18580 v.reset(Op386MOVLconst)
18581 v.AuxInt = 1
18582 return true
18583 }
18584
18585
18586
18587 for {
18588 v_0 := v.Args[0]
18589 if v_0.Op != Op386FlagGT_ULT {
18590 break
18591 }
18592 v.reset(Op386MOVLconst)
18593 v.AuxInt = 0
18594 return true
18595 }
18596
18597
18598
18599 for {
18600 v_0 := v.Args[0]
18601 if v_0.Op != Op386FlagGT_UGT {
18602 break
18603 }
18604 v.reset(Op386MOVLconst)
18605 v.AuxInt = 0
18606 return true
18607 }
18608 return false
18609 }
18610 func rewriteValue386_Op386SETLE_0(v *Value) bool {
18611
18612
18613
18614 for {
18615 v_0 := v.Args[0]
18616 if v_0.Op != Op386InvertFlags {
18617 break
18618 }
18619 x := v_0.Args[0]
18620 v.reset(Op386SETGE)
18621 v.AddArg(x)
18622 return true
18623 }
18624
18625
18626
18627 for {
18628 v_0 := v.Args[0]
18629 if v_0.Op != Op386FlagEQ {
18630 break
18631 }
18632 v.reset(Op386MOVLconst)
18633 v.AuxInt = 1
18634 return true
18635 }
18636
18637
18638
18639 for {
18640 v_0 := v.Args[0]
18641 if v_0.Op != Op386FlagLT_ULT {
18642 break
18643 }
18644 v.reset(Op386MOVLconst)
18645 v.AuxInt = 1
18646 return true
18647 }
18648
18649
18650
18651 for {
18652 v_0 := v.Args[0]
18653 if v_0.Op != Op386FlagLT_UGT {
18654 break
18655 }
18656 v.reset(Op386MOVLconst)
18657 v.AuxInt = 1
18658 return true
18659 }
18660
18661
18662
18663 for {
18664 v_0 := v.Args[0]
18665 if v_0.Op != Op386FlagGT_ULT {
18666 break
18667 }
18668 v.reset(Op386MOVLconst)
18669 v.AuxInt = 0
18670 return true
18671 }
18672
18673
18674
18675 for {
18676 v_0 := v.Args[0]
18677 if v_0.Op != Op386FlagGT_UGT {
18678 break
18679 }
18680 v.reset(Op386MOVLconst)
18681 v.AuxInt = 0
18682 return true
18683 }
18684 return false
18685 }
18686 func rewriteValue386_Op386SETNE_0(v *Value) bool {
18687
18688
18689
18690 for {
18691 v_0 := v.Args[0]
18692 if v_0.Op != Op386InvertFlags {
18693 break
18694 }
18695 x := v_0.Args[0]
18696 v.reset(Op386SETNE)
18697 v.AddArg(x)
18698 return true
18699 }
18700
18701
18702
18703 for {
18704 v_0 := v.Args[0]
18705 if v_0.Op != Op386FlagEQ {
18706 break
18707 }
18708 v.reset(Op386MOVLconst)
18709 v.AuxInt = 0
18710 return true
18711 }
18712
18713
18714
18715 for {
18716 v_0 := v.Args[0]
18717 if v_0.Op != Op386FlagLT_ULT {
18718 break
18719 }
18720 v.reset(Op386MOVLconst)
18721 v.AuxInt = 1
18722 return true
18723 }
18724
18725
18726
18727 for {
18728 v_0 := v.Args[0]
18729 if v_0.Op != Op386FlagLT_UGT {
18730 break
18731 }
18732 v.reset(Op386MOVLconst)
18733 v.AuxInt = 1
18734 return true
18735 }
18736
18737
18738
18739 for {
18740 v_0 := v.Args[0]
18741 if v_0.Op != Op386FlagGT_ULT {
18742 break
18743 }
18744 v.reset(Op386MOVLconst)
18745 v.AuxInt = 1
18746 return true
18747 }
18748
18749
18750
18751 for {
18752 v_0 := v.Args[0]
18753 if v_0.Op != Op386FlagGT_UGT {
18754 break
18755 }
18756 v.reset(Op386MOVLconst)
18757 v.AuxInt = 1
18758 return true
18759 }
18760 return false
18761 }
18762 func rewriteValue386_Op386SHLL_0(v *Value) bool {
18763
18764
18765
18766 for {
18767 _ = v.Args[1]
18768 x := v.Args[0]
18769 v_1 := v.Args[1]
18770 if v_1.Op != Op386MOVLconst {
18771 break
18772 }
18773 c := v_1.AuxInt
18774 v.reset(Op386SHLLconst)
18775 v.AuxInt = c & 31
18776 v.AddArg(x)
18777 return true
18778 }
18779
18780
18781
18782 for {
18783 _ = v.Args[1]
18784 x := v.Args[0]
18785 v_1 := v.Args[1]
18786 if v_1.Op != Op386ANDLconst {
18787 break
18788 }
18789 if v_1.AuxInt != 31 {
18790 break
18791 }
18792 y := v_1.Args[0]
18793 v.reset(Op386SHLL)
18794 v.AddArg(x)
18795 v.AddArg(y)
18796 return true
18797 }
18798 return false
18799 }
18800 func rewriteValue386_Op386SHLLconst_0(v *Value) bool {
18801
18802
18803
18804 for {
18805 if v.AuxInt != 0 {
18806 break
18807 }
18808 x := v.Args[0]
18809 v.reset(OpCopy)
18810 v.Type = x.Type
18811 v.AddArg(x)
18812 return true
18813 }
18814 return false
18815 }
18816 func rewriteValue386_Op386SHRB_0(v *Value) bool {
18817
18818
18819
18820 for {
18821 _ = v.Args[1]
18822 x := v.Args[0]
18823 v_1 := v.Args[1]
18824 if v_1.Op != Op386MOVLconst {
18825 break
18826 }
18827 c := v_1.AuxInt
18828 if !(c&31 < 8) {
18829 break
18830 }
18831 v.reset(Op386SHRBconst)
18832 v.AuxInt = c & 31
18833 v.AddArg(x)
18834 return true
18835 }
18836
18837
18838
18839 for {
18840 _ = v.Args[1]
18841 v_1 := v.Args[1]
18842 if v_1.Op != Op386MOVLconst {
18843 break
18844 }
18845 c := v_1.AuxInt
18846 if !(c&31 >= 8) {
18847 break
18848 }
18849 v.reset(Op386MOVLconst)
18850 v.AuxInt = 0
18851 return true
18852 }
18853 return false
18854 }
18855 func rewriteValue386_Op386SHRBconst_0(v *Value) bool {
18856
18857
18858
18859 for {
18860 if v.AuxInt != 0 {
18861 break
18862 }
18863 x := v.Args[0]
18864 v.reset(OpCopy)
18865 v.Type = x.Type
18866 v.AddArg(x)
18867 return true
18868 }
18869 return false
18870 }
18871 func rewriteValue386_Op386SHRL_0(v *Value) bool {
18872
18873
18874
18875 for {
18876 _ = v.Args[1]
18877 x := v.Args[0]
18878 v_1 := v.Args[1]
18879 if v_1.Op != Op386MOVLconst {
18880 break
18881 }
18882 c := v_1.AuxInt
18883 v.reset(Op386SHRLconst)
18884 v.AuxInt = c & 31
18885 v.AddArg(x)
18886 return true
18887 }
18888
18889
18890
18891 for {
18892 _ = v.Args[1]
18893 x := v.Args[0]
18894 v_1 := v.Args[1]
18895 if v_1.Op != Op386ANDLconst {
18896 break
18897 }
18898 if v_1.AuxInt != 31 {
18899 break
18900 }
18901 y := v_1.Args[0]
18902 v.reset(Op386SHRL)
18903 v.AddArg(x)
18904 v.AddArg(y)
18905 return true
18906 }
18907 return false
18908 }
18909 func rewriteValue386_Op386SHRLconst_0(v *Value) bool {
18910
18911
18912
18913 for {
18914 if v.AuxInt != 0 {
18915 break
18916 }
18917 x := v.Args[0]
18918 v.reset(OpCopy)
18919 v.Type = x.Type
18920 v.AddArg(x)
18921 return true
18922 }
18923 return false
18924 }
18925 func rewriteValue386_Op386SHRW_0(v *Value) bool {
18926
18927
18928
18929 for {
18930 _ = v.Args[1]
18931 x := v.Args[0]
18932 v_1 := v.Args[1]
18933 if v_1.Op != Op386MOVLconst {
18934 break
18935 }
18936 c := v_1.AuxInt
18937 if !(c&31 < 16) {
18938 break
18939 }
18940 v.reset(Op386SHRWconst)
18941 v.AuxInt = c & 31
18942 v.AddArg(x)
18943 return true
18944 }
18945
18946
18947
18948 for {
18949 _ = v.Args[1]
18950 v_1 := v.Args[1]
18951 if v_1.Op != Op386MOVLconst {
18952 break
18953 }
18954 c := v_1.AuxInt
18955 if !(c&31 >= 16) {
18956 break
18957 }
18958 v.reset(Op386MOVLconst)
18959 v.AuxInt = 0
18960 return true
18961 }
18962 return false
18963 }
18964 func rewriteValue386_Op386SHRWconst_0(v *Value) bool {
18965
18966
18967
18968 for {
18969 if v.AuxInt != 0 {
18970 break
18971 }
18972 x := v.Args[0]
18973 v.reset(OpCopy)
18974 v.Type = x.Type
18975 v.AddArg(x)
18976 return true
18977 }
18978 return false
18979 }
18980 func rewriteValue386_Op386SUBL_0(v *Value) bool {
18981 b := v.Block
18982
18983
18984
18985 for {
18986 _ = v.Args[1]
18987 x := v.Args[0]
18988 v_1 := v.Args[1]
18989 if v_1.Op != Op386MOVLconst {
18990 break
18991 }
18992 c := v_1.AuxInt
18993 v.reset(Op386SUBLconst)
18994 v.AuxInt = c
18995 v.AddArg(x)
18996 return true
18997 }
18998
18999
19000
19001 for {
19002 x := v.Args[1]
19003 v_0 := v.Args[0]
19004 if v_0.Op != Op386MOVLconst {
19005 break
19006 }
19007 c := v_0.AuxInt
19008 v.reset(Op386NEGL)
19009 v0 := b.NewValue0(v.Pos, Op386SUBLconst, v.Type)
19010 v0.AuxInt = c
19011 v0.AddArg(x)
19012 v.AddArg(v0)
19013 return true
19014 }
19015
19016
19017
19018 for {
19019 _ = v.Args[1]
19020 x := v.Args[0]
19021 l := v.Args[1]
19022 if l.Op != Op386MOVLload {
19023 break
19024 }
19025 off := l.AuxInt
19026 sym := l.Aux
19027 mem := l.Args[1]
19028 ptr := l.Args[0]
19029 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
19030 break
19031 }
19032 v.reset(Op386SUBLload)
19033 v.AuxInt = off
19034 v.Aux = sym
19035 v.AddArg(x)
19036 v.AddArg(ptr)
19037 v.AddArg(mem)
19038 return true
19039 }
19040
19041
19042
19043 for {
19044 _ = v.Args[1]
19045 x := v.Args[0]
19046 l := v.Args[1]
19047 if l.Op != Op386MOVLloadidx4 {
19048 break
19049 }
19050 off := l.AuxInt
19051 sym := l.Aux
19052 mem := l.Args[2]
19053 ptr := l.Args[0]
19054 idx := l.Args[1]
19055 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
19056 break
19057 }
19058 v.reset(Op386SUBLloadidx4)
19059 v.AuxInt = off
19060 v.Aux = sym
19061 v.AddArg(x)
19062 v.AddArg(ptr)
19063 v.AddArg(idx)
19064 v.AddArg(mem)
19065 return true
19066 }
19067
19068
19069
19070 for {
19071 x := v.Args[1]
19072 if x != v.Args[0] {
19073 break
19074 }
19075 v.reset(Op386MOVLconst)
19076 v.AuxInt = 0
19077 return true
19078 }
19079 return false
19080 }
19081 func rewriteValue386_Op386SUBLcarry_0(v *Value) bool {
19082
19083
19084
19085 for {
19086 _ = v.Args[1]
19087 x := v.Args[0]
19088 v_1 := v.Args[1]
19089 if v_1.Op != Op386MOVLconst {
19090 break
19091 }
19092 c := v_1.AuxInt
19093 v.reset(Op386SUBLconstcarry)
19094 v.AuxInt = c
19095 v.AddArg(x)
19096 return true
19097 }
19098 return false
19099 }
19100 func rewriteValue386_Op386SUBLconst_0(v *Value) bool {
19101
19102
19103
19104 for {
19105 c := v.AuxInt
19106 x := v.Args[0]
19107 if !(int32(c) == 0) {
19108 break
19109 }
19110 v.reset(OpCopy)
19111 v.Type = x.Type
19112 v.AddArg(x)
19113 return true
19114 }
19115
19116
19117
19118 for {
19119 c := v.AuxInt
19120 x := v.Args[0]
19121 v.reset(Op386ADDLconst)
19122 v.AuxInt = int64(int32(-c))
19123 v.AddArg(x)
19124 return true
19125 }
19126 }
19127 func rewriteValue386_Op386SUBLload_0(v *Value) bool {
19128 b := v.Block
19129 config := b.Func.Config
19130
19131
19132
19133 for {
19134 off1 := v.AuxInt
19135 sym := v.Aux
19136 mem := v.Args[2]
19137 val := v.Args[0]
19138 v_1 := v.Args[1]
19139 if v_1.Op != Op386ADDLconst {
19140 break
19141 }
19142 off2 := v_1.AuxInt
19143 base := v_1.Args[0]
19144 if !(is32Bit(off1 + off2)) {
19145 break
19146 }
19147 v.reset(Op386SUBLload)
19148 v.AuxInt = off1 + off2
19149 v.Aux = sym
19150 v.AddArg(val)
19151 v.AddArg(base)
19152 v.AddArg(mem)
19153 return true
19154 }
19155
19156
19157
19158 for {
19159 off1 := v.AuxInt
19160 sym1 := v.Aux
19161 mem := v.Args[2]
19162 val := v.Args[0]
19163 v_1 := v.Args[1]
19164 if v_1.Op != Op386LEAL {
19165 break
19166 }
19167 off2 := v_1.AuxInt
19168 sym2 := v_1.Aux
19169 base := v_1.Args[0]
19170 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
19171 break
19172 }
19173 v.reset(Op386SUBLload)
19174 v.AuxInt = off1 + off2
19175 v.Aux = mergeSym(sym1, sym2)
19176 v.AddArg(val)
19177 v.AddArg(base)
19178 v.AddArg(mem)
19179 return true
19180 }
19181
19182
19183
19184 for {
19185 off1 := v.AuxInt
19186 sym1 := v.Aux
19187 mem := v.Args[2]
19188 val := v.Args[0]
19189 v_1 := v.Args[1]
19190 if v_1.Op != Op386LEAL4 {
19191 break
19192 }
19193 off2 := v_1.AuxInt
19194 sym2 := v_1.Aux
19195 idx := v_1.Args[1]
19196 ptr := v_1.Args[0]
19197 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
19198 break
19199 }
19200 v.reset(Op386SUBLloadidx4)
19201 v.AuxInt = off1 + off2
19202 v.Aux = mergeSym(sym1, sym2)
19203 v.AddArg(val)
19204 v.AddArg(ptr)
19205 v.AddArg(idx)
19206 v.AddArg(mem)
19207 return true
19208 }
19209 return false
19210 }
19211 func rewriteValue386_Op386SUBLloadidx4_0(v *Value) bool {
19212 b := v.Block
19213 config := b.Func.Config
19214
19215
19216
19217 for {
19218 off1 := v.AuxInt
19219 sym := v.Aux
19220 mem := v.Args[3]
19221 val := v.Args[0]
19222 v_1 := v.Args[1]
19223 if v_1.Op != Op386ADDLconst {
19224 break
19225 }
19226 off2 := v_1.AuxInt
19227 base := v_1.Args[0]
19228 idx := v.Args[2]
19229 if !(is32Bit(off1 + off2)) {
19230 break
19231 }
19232 v.reset(Op386SUBLloadidx4)
19233 v.AuxInt = off1 + off2
19234 v.Aux = sym
19235 v.AddArg(val)
19236 v.AddArg(base)
19237 v.AddArg(idx)
19238 v.AddArg(mem)
19239 return true
19240 }
19241
19242
19243
19244 for {
19245 off1 := v.AuxInt
19246 sym := v.Aux
19247 mem := v.Args[3]
19248 val := v.Args[0]
19249 base := v.Args[1]
19250 v_2 := v.Args[2]
19251 if v_2.Op != Op386ADDLconst {
19252 break
19253 }
19254 off2 := v_2.AuxInt
19255 idx := v_2.Args[0]
19256 if !(is32Bit(off1 + off2*4)) {
19257 break
19258 }
19259 v.reset(Op386SUBLloadidx4)
19260 v.AuxInt = off1 + off2*4
19261 v.Aux = sym
19262 v.AddArg(val)
19263 v.AddArg(base)
19264 v.AddArg(idx)
19265 v.AddArg(mem)
19266 return true
19267 }
19268
19269
19270
19271 for {
19272 off1 := v.AuxInt
19273 sym1 := v.Aux
19274 mem := v.Args[3]
19275 val := v.Args[0]
19276 v_1 := v.Args[1]
19277 if v_1.Op != Op386LEAL {
19278 break
19279 }
19280 off2 := v_1.AuxInt
19281 sym2 := v_1.Aux
19282 base := v_1.Args[0]
19283 idx := v.Args[2]
19284 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
19285 break
19286 }
19287 v.reset(Op386SUBLloadidx4)
19288 v.AuxInt = off1 + off2
19289 v.Aux = mergeSym(sym1, sym2)
19290 v.AddArg(val)
19291 v.AddArg(base)
19292 v.AddArg(idx)
19293 v.AddArg(mem)
19294 return true
19295 }
19296 return false
19297 }
19298 func rewriteValue386_Op386SUBLmodify_0(v *Value) bool {
19299 b := v.Block
19300 config := b.Func.Config
19301
19302
19303
19304 for {
19305 off1 := v.AuxInt
19306 sym := v.Aux
19307 mem := v.Args[2]
19308 v_0 := v.Args[0]
19309 if v_0.Op != Op386ADDLconst {
19310 break
19311 }
19312 off2 := v_0.AuxInt
19313 base := v_0.Args[0]
19314 val := v.Args[1]
19315 if !(is32Bit(off1 + off2)) {
19316 break
19317 }
19318 v.reset(Op386SUBLmodify)
19319 v.AuxInt = off1 + off2
19320 v.Aux = sym
19321 v.AddArg(base)
19322 v.AddArg(val)
19323 v.AddArg(mem)
19324 return true
19325 }
19326
19327
19328
19329 for {
19330 off1 := v.AuxInt
19331 sym1 := v.Aux
19332 mem := v.Args[2]
19333 v_0 := v.Args[0]
19334 if v_0.Op != Op386LEAL {
19335 break
19336 }
19337 off2 := v_0.AuxInt
19338 sym2 := v_0.Aux
19339 base := v_0.Args[0]
19340 val := v.Args[1]
19341 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
19342 break
19343 }
19344 v.reset(Op386SUBLmodify)
19345 v.AuxInt = off1 + off2
19346 v.Aux = mergeSym(sym1, sym2)
19347 v.AddArg(base)
19348 v.AddArg(val)
19349 v.AddArg(mem)
19350 return true
19351 }
19352 return false
19353 }
19354 func rewriteValue386_Op386SUBLmodifyidx4_0(v *Value) bool {
19355 b := v.Block
19356 config := b.Func.Config
19357
19358
19359
19360 for {
19361 off1 := v.AuxInt
19362 sym := v.Aux
19363 mem := v.Args[3]
19364 v_0 := v.Args[0]
19365 if v_0.Op != Op386ADDLconst {
19366 break
19367 }
19368 off2 := v_0.AuxInt
19369 base := v_0.Args[0]
19370 idx := v.Args[1]
19371 val := v.Args[2]
19372 if !(is32Bit(off1 + off2)) {
19373 break
19374 }
19375 v.reset(Op386SUBLmodifyidx4)
19376 v.AuxInt = off1 + off2
19377 v.Aux = sym
19378 v.AddArg(base)
19379 v.AddArg(idx)
19380 v.AddArg(val)
19381 v.AddArg(mem)
19382 return true
19383 }
19384
19385
19386
19387 for {
19388 off1 := v.AuxInt
19389 sym := v.Aux
19390 mem := v.Args[3]
19391 base := v.Args[0]
19392 v_1 := v.Args[1]
19393 if v_1.Op != Op386ADDLconst {
19394 break
19395 }
19396 off2 := v_1.AuxInt
19397 idx := v_1.Args[0]
19398 val := v.Args[2]
19399 if !(is32Bit(off1 + off2*4)) {
19400 break
19401 }
19402 v.reset(Op386SUBLmodifyidx4)
19403 v.AuxInt = off1 + off2*4
19404 v.Aux = sym
19405 v.AddArg(base)
19406 v.AddArg(idx)
19407 v.AddArg(val)
19408 v.AddArg(mem)
19409 return true
19410 }
19411
19412
19413
19414 for {
19415 off1 := v.AuxInt
19416 sym1 := v.Aux
19417 mem := v.Args[3]
19418 v_0 := v.Args[0]
19419 if v_0.Op != Op386LEAL {
19420 break
19421 }
19422 off2 := v_0.AuxInt
19423 sym2 := v_0.Aux
19424 base := v_0.Args[0]
19425 idx := v.Args[1]
19426 val := v.Args[2]
19427 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
19428 break
19429 }
19430 v.reset(Op386SUBLmodifyidx4)
19431 v.AuxInt = off1 + off2
19432 v.Aux = mergeSym(sym1, sym2)
19433 v.AddArg(base)
19434 v.AddArg(idx)
19435 v.AddArg(val)
19436 v.AddArg(mem)
19437 return true
19438 }
19439
19440
19441
19442 for {
19443 off := v.AuxInt
19444 sym := v.Aux
19445 mem := v.Args[3]
19446 ptr := v.Args[0]
19447 idx := v.Args[1]
19448 v_2 := v.Args[2]
19449 if v_2.Op != Op386MOVLconst {
19450 break
19451 }
19452 c := v_2.AuxInt
19453 if !(validValAndOff(-c, off)) {
19454 break
19455 }
19456 v.reset(Op386ADDLconstmodifyidx4)
19457 v.AuxInt = makeValAndOff(-c, off)
19458 v.Aux = sym
19459 v.AddArg(ptr)
19460 v.AddArg(idx)
19461 v.AddArg(mem)
19462 return true
19463 }
19464 return false
19465 }
19466 func rewriteValue386_Op386SUBSD_0(v *Value) bool {
19467 b := v.Block
19468 config := b.Func.Config
19469
19470
19471
19472 for {
19473 _ = v.Args[1]
19474 x := v.Args[0]
19475 l := v.Args[1]
19476 if l.Op != Op386MOVSDload {
19477 break
19478 }
19479 off := l.AuxInt
19480 sym := l.Aux
19481 mem := l.Args[1]
19482 ptr := l.Args[0]
19483 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
19484 break
19485 }
19486 v.reset(Op386SUBSDload)
19487 v.AuxInt = off
19488 v.Aux = sym
19489 v.AddArg(x)
19490 v.AddArg(ptr)
19491 v.AddArg(mem)
19492 return true
19493 }
19494 return false
19495 }
19496 func rewriteValue386_Op386SUBSDload_0(v *Value) bool {
19497 b := v.Block
19498 config := b.Func.Config
19499
19500
19501
19502 for {
19503 off1 := v.AuxInt
19504 sym := v.Aux
19505 mem := v.Args[2]
19506 val := v.Args[0]
19507 v_1 := v.Args[1]
19508 if v_1.Op != Op386ADDLconst {
19509 break
19510 }
19511 off2 := v_1.AuxInt
19512 base := v_1.Args[0]
19513 if !(is32Bit(off1 + off2)) {
19514 break
19515 }
19516 v.reset(Op386SUBSDload)
19517 v.AuxInt = off1 + off2
19518 v.Aux = sym
19519 v.AddArg(val)
19520 v.AddArg(base)
19521 v.AddArg(mem)
19522 return true
19523 }
19524
19525
19526
19527 for {
19528 off1 := v.AuxInt
19529 sym1 := v.Aux
19530 mem := v.Args[2]
19531 val := v.Args[0]
19532 v_1 := v.Args[1]
19533 if v_1.Op != Op386LEAL {
19534 break
19535 }
19536 off2 := v_1.AuxInt
19537 sym2 := v_1.Aux
19538 base := v_1.Args[0]
19539 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
19540 break
19541 }
19542 v.reset(Op386SUBSDload)
19543 v.AuxInt = off1 + off2
19544 v.Aux = mergeSym(sym1, sym2)
19545 v.AddArg(val)
19546 v.AddArg(base)
19547 v.AddArg(mem)
19548 return true
19549 }
19550 return false
19551 }
19552 func rewriteValue386_Op386SUBSS_0(v *Value) bool {
19553 b := v.Block
19554 config := b.Func.Config
19555
19556
19557
19558 for {
19559 _ = v.Args[1]
19560 x := v.Args[0]
19561 l := v.Args[1]
19562 if l.Op != Op386MOVSSload {
19563 break
19564 }
19565 off := l.AuxInt
19566 sym := l.Aux
19567 mem := l.Args[1]
19568 ptr := l.Args[0]
19569 if !(canMergeLoadClobber(v, l, x) && !config.use387 && clobber(l)) {
19570 break
19571 }
19572 v.reset(Op386SUBSSload)
19573 v.AuxInt = off
19574 v.Aux = sym
19575 v.AddArg(x)
19576 v.AddArg(ptr)
19577 v.AddArg(mem)
19578 return true
19579 }
19580 return false
19581 }
19582 func rewriteValue386_Op386SUBSSload_0(v *Value) bool {
19583 b := v.Block
19584 config := b.Func.Config
19585
19586
19587
19588 for {
19589 off1 := v.AuxInt
19590 sym := v.Aux
19591 mem := v.Args[2]
19592 val := v.Args[0]
19593 v_1 := v.Args[1]
19594 if v_1.Op != Op386ADDLconst {
19595 break
19596 }
19597 off2 := v_1.AuxInt
19598 base := v_1.Args[0]
19599 if !(is32Bit(off1 + off2)) {
19600 break
19601 }
19602 v.reset(Op386SUBSSload)
19603 v.AuxInt = off1 + off2
19604 v.Aux = sym
19605 v.AddArg(val)
19606 v.AddArg(base)
19607 v.AddArg(mem)
19608 return true
19609 }
19610
19611
19612
19613 for {
19614 off1 := v.AuxInt
19615 sym1 := v.Aux
19616 mem := v.Args[2]
19617 val := v.Args[0]
19618 v_1 := v.Args[1]
19619 if v_1.Op != Op386LEAL {
19620 break
19621 }
19622 off2 := v_1.AuxInt
19623 sym2 := v_1.Aux
19624 base := v_1.Args[0]
19625 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
19626 break
19627 }
19628 v.reset(Op386SUBSSload)
19629 v.AuxInt = off1 + off2
19630 v.Aux = mergeSym(sym1, sym2)
19631 v.AddArg(val)
19632 v.AddArg(base)
19633 v.AddArg(mem)
19634 return true
19635 }
19636 return false
19637 }
19638 func rewriteValue386_Op386XORL_0(v *Value) bool {
19639
19640
19641
19642 for {
19643 _ = v.Args[1]
19644 x := v.Args[0]
19645 v_1 := v.Args[1]
19646 if v_1.Op != Op386MOVLconst {
19647 break
19648 }
19649 c := v_1.AuxInt
19650 v.reset(Op386XORLconst)
19651 v.AuxInt = c
19652 v.AddArg(x)
19653 return true
19654 }
19655
19656
19657
19658 for {
19659 x := v.Args[1]
19660 v_0 := v.Args[0]
19661 if v_0.Op != Op386MOVLconst {
19662 break
19663 }
19664 c := v_0.AuxInt
19665 v.reset(Op386XORLconst)
19666 v.AuxInt = c
19667 v.AddArg(x)
19668 return true
19669 }
19670
19671
19672
19673 for {
19674 _ = v.Args[1]
19675 v_0 := v.Args[0]
19676 if v_0.Op != Op386SHLLconst {
19677 break
19678 }
19679 c := v_0.AuxInt
19680 x := v_0.Args[0]
19681 v_1 := v.Args[1]
19682 if v_1.Op != Op386SHRLconst {
19683 break
19684 }
19685 d := v_1.AuxInt
19686 if x != v_1.Args[0] {
19687 break
19688 }
19689 if !(d == 32-c) {
19690 break
19691 }
19692 v.reset(Op386ROLLconst)
19693 v.AuxInt = c
19694 v.AddArg(x)
19695 return true
19696 }
19697
19698
19699
19700 for {
19701 _ = v.Args[1]
19702 v_0 := v.Args[0]
19703 if v_0.Op != Op386SHRLconst {
19704 break
19705 }
19706 d := v_0.AuxInt
19707 x := v_0.Args[0]
19708 v_1 := v.Args[1]
19709 if v_1.Op != Op386SHLLconst {
19710 break
19711 }
19712 c := v_1.AuxInt
19713 if x != v_1.Args[0] {
19714 break
19715 }
19716 if !(d == 32-c) {
19717 break
19718 }
19719 v.reset(Op386ROLLconst)
19720 v.AuxInt = c
19721 v.AddArg(x)
19722 return true
19723 }
19724
19725
19726
19727 for {
19728 t := v.Type
19729 _ = v.Args[1]
19730 v_0 := v.Args[0]
19731 if v_0.Op != Op386SHLLconst {
19732 break
19733 }
19734 c := v_0.AuxInt
19735 x := v_0.Args[0]
19736 v_1 := v.Args[1]
19737 if v_1.Op != Op386SHRWconst {
19738 break
19739 }
19740 d := v_1.AuxInt
19741 if x != v_1.Args[0] {
19742 break
19743 }
19744 if !(c < 16 && d == 16-c && t.Size() == 2) {
19745 break
19746 }
19747 v.reset(Op386ROLWconst)
19748 v.AuxInt = c
19749 v.AddArg(x)
19750 return true
19751 }
19752
19753
19754
19755 for {
19756 t := v.Type
19757 _ = v.Args[1]
19758 v_0 := v.Args[0]
19759 if v_0.Op != Op386SHRWconst {
19760 break
19761 }
19762 d := v_0.AuxInt
19763 x := v_0.Args[0]
19764 v_1 := v.Args[1]
19765 if v_1.Op != Op386SHLLconst {
19766 break
19767 }
19768 c := v_1.AuxInt
19769 if x != v_1.Args[0] {
19770 break
19771 }
19772 if !(c < 16 && d == 16-c && t.Size() == 2) {
19773 break
19774 }
19775 v.reset(Op386ROLWconst)
19776 v.AuxInt = c
19777 v.AddArg(x)
19778 return true
19779 }
19780
19781
19782
19783 for {
19784 t := v.Type
19785 _ = v.Args[1]
19786 v_0 := v.Args[0]
19787 if v_0.Op != Op386SHLLconst {
19788 break
19789 }
19790 c := v_0.AuxInt
19791 x := v_0.Args[0]
19792 v_1 := v.Args[1]
19793 if v_1.Op != Op386SHRBconst {
19794 break
19795 }
19796 d := v_1.AuxInt
19797 if x != v_1.Args[0] {
19798 break
19799 }
19800 if !(c < 8 && d == 8-c && t.Size() == 1) {
19801 break
19802 }
19803 v.reset(Op386ROLBconst)
19804 v.AuxInt = c
19805 v.AddArg(x)
19806 return true
19807 }
19808
19809
19810
19811 for {
19812 t := v.Type
19813 _ = v.Args[1]
19814 v_0 := v.Args[0]
19815 if v_0.Op != Op386SHRBconst {
19816 break
19817 }
19818 d := v_0.AuxInt
19819 x := v_0.Args[0]
19820 v_1 := v.Args[1]
19821 if v_1.Op != Op386SHLLconst {
19822 break
19823 }
19824 c := v_1.AuxInt
19825 if x != v_1.Args[0] {
19826 break
19827 }
19828 if !(c < 8 && d == 8-c && t.Size() == 1) {
19829 break
19830 }
19831 v.reset(Op386ROLBconst)
19832 v.AuxInt = c
19833 v.AddArg(x)
19834 return true
19835 }
19836
19837
19838
19839 for {
19840 _ = v.Args[1]
19841 x := v.Args[0]
19842 l := v.Args[1]
19843 if l.Op != Op386MOVLload {
19844 break
19845 }
19846 off := l.AuxInt
19847 sym := l.Aux
19848 mem := l.Args[1]
19849 ptr := l.Args[0]
19850 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
19851 break
19852 }
19853 v.reset(Op386XORLload)
19854 v.AuxInt = off
19855 v.Aux = sym
19856 v.AddArg(x)
19857 v.AddArg(ptr)
19858 v.AddArg(mem)
19859 return true
19860 }
19861
19862
19863
19864 for {
19865 x := v.Args[1]
19866 l := v.Args[0]
19867 if l.Op != Op386MOVLload {
19868 break
19869 }
19870 off := l.AuxInt
19871 sym := l.Aux
19872 mem := l.Args[1]
19873 ptr := l.Args[0]
19874 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
19875 break
19876 }
19877 v.reset(Op386XORLload)
19878 v.AuxInt = off
19879 v.Aux = sym
19880 v.AddArg(x)
19881 v.AddArg(ptr)
19882 v.AddArg(mem)
19883 return true
19884 }
19885 return false
19886 }
19887 func rewriteValue386_Op386XORL_10(v *Value) bool {
19888
19889
19890
19891 for {
19892 _ = v.Args[1]
19893 x := v.Args[0]
19894 l := v.Args[1]
19895 if l.Op != Op386MOVLloadidx4 {
19896 break
19897 }
19898 off := l.AuxInt
19899 sym := l.Aux
19900 mem := l.Args[2]
19901 ptr := l.Args[0]
19902 idx := l.Args[1]
19903 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
19904 break
19905 }
19906 v.reset(Op386XORLloadidx4)
19907 v.AuxInt = off
19908 v.Aux = sym
19909 v.AddArg(x)
19910 v.AddArg(ptr)
19911 v.AddArg(idx)
19912 v.AddArg(mem)
19913 return true
19914 }
19915
19916
19917
19918 for {
19919 x := v.Args[1]
19920 l := v.Args[0]
19921 if l.Op != Op386MOVLloadidx4 {
19922 break
19923 }
19924 off := l.AuxInt
19925 sym := l.Aux
19926 mem := l.Args[2]
19927 ptr := l.Args[0]
19928 idx := l.Args[1]
19929 if !(canMergeLoadClobber(v, l, x) && clobber(l)) {
19930 break
19931 }
19932 v.reset(Op386XORLloadidx4)
19933 v.AuxInt = off
19934 v.Aux = sym
19935 v.AddArg(x)
19936 v.AddArg(ptr)
19937 v.AddArg(idx)
19938 v.AddArg(mem)
19939 return true
19940 }
19941
19942
19943
19944 for {
19945 x := v.Args[1]
19946 if x != v.Args[0] {
19947 break
19948 }
19949 v.reset(Op386MOVLconst)
19950 v.AuxInt = 0
19951 return true
19952 }
19953 return false
19954 }
19955 func rewriteValue386_Op386XORLconst_0(v *Value) bool {
19956
19957
19958
19959 for {
19960 c := v.AuxInt
19961 v_0 := v.Args[0]
19962 if v_0.Op != Op386XORLconst {
19963 break
19964 }
19965 d := v_0.AuxInt
19966 x := v_0.Args[0]
19967 v.reset(Op386XORLconst)
19968 v.AuxInt = c ^ d
19969 v.AddArg(x)
19970 return true
19971 }
19972
19973
19974
19975 for {
19976 c := v.AuxInt
19977 x := v.Args[0]
19978 if !(int32(c) == 0) {
19979 break
19980 }
19981 v.reset(OpCopy)
19982 v.Type = x.Type
19983 v.AddArg(x)
19984 return true
19985 }
19986
19987
19988
19989 for {
19990 c := v.AuxInt
19991 v_0 := v.Args[0]
19992 if v_0.Op != Op386MOVLconst {
19993 break
19994 }
19995 d := v_0.AuxInt
19996 v.reset(Op386MOVLconst)
19997 v.AuxInt = c ^ d
19998 return true
19999 }
20000 return false
20001 }
20002 func rewriteValue386_Op386XORLconstmodify_0(v *Value) bool {
20003 b := v.Block
20004 config := b.Func.Config
20005
20006
20007
20008 for {
20009 valoff1 := v.AuxInt
20010 sym := v.Aux
20011 mem := v.Args[1]
20012 v_0 := v.Args[0]
20013 if v_0.Op != Op386ADDLconst {
20014 break
20015 }
20016 off2 := v_0.AuxInt
20017 base := v_0.Args[0]
20018 if !(ValAndOff(valoff1).canAdd(off2)) {
20019 break
20020 }
20021 v.reset(Op386XORLconstmodify)
20022 v.AuxInt = ValAndOff(valoff1).add(off2)
20023 v.Aux = sym
20024 v.AddArg(base)
20025 v.AddArg(mem)
20026 return true
20027 }
20028
20029
20030
20031 for {
20032 valoff1 := v.AuxInt
20033 sym1 := v.Aux
20034 mem := v.Args[1]
20035 v_0 := v.Args[0]
20036 if v_0.Op != Op386LEAL {
20037 break
20038 }
20039 off2 := v_0.AuxInt
20040 sym2 := v_0.Aux
20041 base := v_0.Args[0]
20042 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
20043 break
20044 }
20045 v.reset(Op386XORLconstmodify)
20046 v.AuxInt = ValAndOff(valoff1).add(off2)
20047 v.Aux = mergeSym(sym1, sym2)
20048 v.AddArg(base)
20049 v.AddArg(mem)
20050 return true
20051 }
20052 return false
20053 }
20054 func rewriteValue386_Op386XORLconstmodifyidx4_0(v *Value) bool {
20055 b := v.Block
20056 config := b.Func.Config
20057
20058
20059
20060 for {
20061 valoff1 := v.AuxInt
20062 sym := v.Aux
20063 mem := v.Args[2]
20064 v_0 := v.Args[0]
20065 if v_0.Op != Op386ADDLconst {
20066 break
20067 }
20068 off2 := v_0.AuxInt
20069 base := v_0.Args[0]
20070 idx := v.Args[1]
20071 if !(ValAndOff(valoff1).canAdd(off2)) {
20072 break
20073 }
20074 v.reset(Op386XORLconstmodifyidx4)
20075 v.AuxInt = ValAndOff(valoff1).add(off2)
20076 v.Aux = sym
20077 v.AddArg(base)
20078 v.AddArg(idx)
20079 v.AddArg(mem)
20080 return true
20081 }
20082
20083
20084
20085 for {
20086 valoff1 := v.AuxInt
20087 sym := v.Aux
20088 mem := v.Args[2]
20089 base := v.Args[0]
20090 v_1 := v.Args[1]
20091 if v_1.Op != Op386ADDLconst {
20092 break
20093 }
20094 off2 := v_1.AuxInt
20095 idx := v_1.Args[0]
20096 if !(ValAndOff(valoff1).canAdd(off2 * 4)) {
20097 break
20098 }
20099 v.reset(Op386XORLconstmodifyidx4)
20100 v.AuxInt = ValAndOff(valoff1).add(off2 * 4)
20101 v.Aux = sym
20102 v.AddArg(base)
20103 v.AddArg(idx)
20104 v.AddArg(mem)
20105 return true
20106 }
20107
20108
20109
20110 for {
20111 valoff1 := v.AuxInt
20112 sym1 := v.Aux
20113 mem := v.Args[2]
20114 v_0 := v.Args[0]
20115 if v_0.Op != Op386LEAL {
20116 break
20117 }
20118 off2 := v_0.AuxInt
20119 sym2 := v_0.Aux
20120 base := v_0.Args[0]
20121 idx := v.Args[1]
20122 if !(ValAndOff(valoff1).canAdd(off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
20123 break
20124 }
20125 v.reset(Op386XORLconstmodifyidx4)
20126 v.AuxInt = ValAndOff(valoff1).add(off2)
20127 v.Aux = mergeSym(sym1, sym2)
20128 v.AddArg(base)
20129 v.AddArg(idx)
20130 v.AddArg(mem)
20131 return true
20132 }
20133 return false
20134 }
20135 func rewriteValue386_Op386XORLload_0(v *Value) bool {
20136 b := v.Block
20137 config := b.Func.Config
20138
20139
20140
20141 for {
20142 off1 := v.AuxInt
20143 sym := v.Aux
20144 mem := v.Args[2]
20145 val := v.Args[0]
20146 v_1 := v.Args[1]
20147 if v_1.Op != Op386ADDLconst {
20148 break
20149 }
20150 off2 := v_1.AuxInt
20151 base := v_1.Args[0]
20152 if !(is32Bit(off1 + off2)) {
20153 break
20154 }
20155 v.reset(Op386XORLload)
20156 v.AuxInt = off1 + off2
20157 v.Aux = sym
20158 v.AddArg(val)
20159 v.AddArg(base)
20160 v.AddArg(mem)
20161 return true
20162 }
20163
20164
20165
20166 for {
20167 off1 := v.AuxInt
20168 sym1 := v.Aux
20169 mem := v.Args[2]
20170 val := v.Args[0]
20171 v_1 := v.Args[1]
20172 if v_1.Op != Op386LEAL {
20173 break
20174 }
20175 off2 := v_1.AuxInt
20176 sym2 := v_1.Aux
20177 base := v_1.Args[0]
20178 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
20179 break
20180 }
20181 v.reset(Op386XORLload)
20182 v.AuxInt = off1 + off2
20183 v.Aux = mergeSym(sym1, sym2)
20184 v.AddArg(val)
20185 v.AddArg(base)
20186 v.AddArg(mem)
20187 return true
20188 }
20189
20190
20191
20192 for {
20193 off1 := v.AuxInt
20194 sym1 := v.Aux
20195 mem := v.Args[2]
20196 val := v.Args[0]
20197 v_1 := v.Args[1]
20198 if v_1.Op != Op386LEAL4 {
20199 break
20200 }
20201 off2 := v_1.AuxInt
20202 sym2 := v_1.Aux
20203 idx := v_1.Args[1]
20204 ptr := v_1.Args[0]
20205 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
20206 break
20207 }
20208 v.reset(Op386XORLloadidx4)
20209 v.AuxInt = off1 + off2
20210 v.Aux = mergeSym(sym1, sym2)
20211 v.AddArg(val)
20212 v.AddArg(ptr)
20213 v.AddArg(idx)
20214 v.AddArg(mem)
20215 return true
20216 }
20217 return false
20218 }
20219 func rewriteValue386_Op386XORLloadidx4_0(v *Value) bool {
20220 b := v.Block
20221 config := b.Func.Config
20222
20223
20224
20225 for {
20226 off1 := v.AuxInt
20227 sym := v.Aux
20228 mem := v.Args[3]
20229 val := v.Args[0]
20230 v_1 := v.Args[1]
20231 if v_1.Op != Op386ADDLconst {
20232 break
20233 }
20234 off2 := v_1.AuxInt
20235 base := v_1.Args[0]
20236 idx := v.Args[2]
20237 if !(is32Bit(off1 + off2)) {
20238 break
20239 }
20240 v.reset(Op386XORLloadidx4)
20241 v.AuxInt = off1 + off2
20242 v.Aux = sym
20243 v.AddArg(val)
20244 v.AddArg(base)
20245 v.AddArg(idx)
20246 v.AddArg(mem)
20247 return true
20248 }
20249
20250
20251
20252 for {
20253 off1 := v.AuxInt
20254 sym := v.Aux
20255 mem := v.Args[3]
20256 val := v.Args[0]
20257 base := v.Args[1]
20258 v_2 := v.Args[2]
20259 if v_2.Op != Op386ADDLconst {
20260 break
20261 }
20262 off2 := v_2.AuxInt
20263 idx := v_2.Args[0]
20264 if !(is32Bit(off1 + off2*4)) {
20265 break
20266 }
20267 v.reset(Op386XORLloadidx4)
20268 v.AuxInt = off1 + off2*4
20269 v.Aux = sym
20270 v.AddArg(val)
20271 v.AddArg(base)
20272 v.AddArg(idx)
20273 v.AddArg(mem)
20274 return true
20275 }
20276
20277
20278
20279 for {
20280 off1 := v.AuxInt
20281 sym1 := v.Aux
20282 mem := v.Args[3]
20283 val := v.Args[0]
20284 v_1 := v.Args[1]
20285 if v_1.Op != Op386LEAL {
20286 break
20287 }
20288 off2 := v_1.AuxInt
20289 sym2 := v_1.Aux
20290 base := v_1.Args[0]
20291 idx := v.Args[2]
20292 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
20293 break
20294 }
20295 v.reset(Op386XORLloadidx4)
20296 v.AuxInt = off1 + off2
20297 v.Aux = mergeSym(sym1, sym2)
20298 v.AddArg(val)
20299 v.AddArg(base)
20300 v.AddArg(idx)
20301 v.AddArg(mem)
20302 return true
20303 }
20304 return false
20305 }
20306 func rewriteValue386_Op386XORLmodify_0(v *Value) bool {
20307 b := v.Block
20308 config := b.Func.Config
20309
20310
20311
20312 for {
20313 off1 := v.AuxInt
20314 sym := v.Aux
20315 mem := v.Args[2]
20316 v_0 := v.Args[0]
20317 if v_0.Op != Op386ADDLconst {
20318 break
20319 }
20320 off2 := v_0.AuxInt
20321 base := v_0.Args[0]
20322 val := v.Args[1]
20323 if !(is32Bit(off1 + off2)) {
20324 break
20325 }
20326 v.reset(Op386XORLmodify)
20327 v.AuxInt = off1 + off2
20328 v.Aux = sym
20329 v.AddArg(base)
20330 v.AddArg(val)
20331 v.AddArg(mem)
20332 return true
20333 }
20334
20335
20336
20337 for {
20338 off1 := v.AuxInt
20339 sym1 := v.Aux
20340 mem := v.Args[2]
20341 v_0 := v.Args[0]
20342 if v_0.Op != Op386LEAL {
20343 break
20344 }
20345 off2 := v_0.AuxInt
20346 sym2 := v_0.Aux
20347 base := v_0.Args[0]
20348 val := v.Args[1]
20349 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
20350 break
20351 }
20352 v.reset(Op386XORLmodify)
20353 v.AuxInt = off1 + off2
20354 v.Aux = mergeSym(sym1, sym2)
20355 v.AddArg(base)
20356 v.AddArg(val)
20357 v.AddArg(mem)
20358 return true
20359 }
20360 return false
20361 }
20362 func rewriteValue386_Op386XORLmodifyidx4_0(v *Value) bool {
20363 b := v.Block
20364 config := b.Func.Config
20365
20366
20367
20368 for {
20369 off1 := v.AuxInt
20370 sym := v.Aux
20371 mem := v.Args[3]
20372 v_0 := v.Args[0]
20373 if v_0.Op != Op386ADDLconst {
20374 break
20375 }
20376 off2 := v_0.AuxInt
20377 base := v_0.Args[0]
20378 idx := v.Args[1]
20379 val := v.Args[2]
20380 if !(is32Bit(off1 + off2)) {
20381 break
20382 }
20383 v.reset(Op386XORLmodifyidx4)
20384 v.AuxInt = off1 + off2
20385 v.Aux = sym
20386 v.AddArg(base)
20387 v.AddArg(idx)
20388 v.AddArg(val)
20389 v.AddArg(mem)
20390 return true
20391 }
20392
20393
20394
20395 for {
20396 off1 := v.AuxInt
20397 sym := v.Aux
20398 mem := v.Args[3]
20399 base := v.Args[0]
20400 v_1 := v.Args[1]
20401 if v_1.Op != Op386ADDLconst {
20402 break
20403 }
20404 off2 := v_1.AuxInt
20405 idx := v_1.Args[0]
20406 val := v.Args[2]
20407 if !(is32Bit(off1 + off2*4)) {
20408 break
20409 }
20410 v.reset(Op386XORLmodifyidx4)
20411 v.AuxInt = off1 + off2*4
20412 v.Aux = sym
20413 v.AddArg(base)
20414 v.AddArg(idx)
20415 v.AddArg(val)
20416 v.AddArg(mem)
20417 return true
20418 }
20419
20420
20421
20422 for {
20423 off1 := v.AuxInt
20424 sym1 := v.Aux
20425 mem := v.Args[3]
20426 v_0 := v.Args[0]
20427 if v_0.Op != Op386LEAL {
20428 break
20429 }
20430 off2 := v_0.AuxInt
20431 sym2 := v_0.Aux
20432 base := v_0.Args[0]
20433 idx := v.Args[1]
20434 val := v.Args[2]
20435 if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
20436 break
20437 }
20438 v.reset(Op386XORLmodifyidx4)
20439 v.AuxInt = off1 + off2
20440 v.Aux = mergeSym(sym1, sym2)
20441 v.AddArg(base)
20442 v.AddArg(idx)
20443 v.AddArg(val)
20444 v.AddArg(mem)
20445 return true
20446 }
20447
20448
20449
20450 for {
20451 off := v.AuxInt
20452 sym := v.Aux
20453 mem := v.Args[3]
20454 ptr := v.Args[0]
20455 idx := v.Args[1]
20456 v_2 := v.Args[2]
20457 if v_2.Op != Op386MOVLconst {
20458 break
20459 }
20460 c := v_2.AuxInt
20461 if !(validValAndOff(c, off)) {
20462 break
20463 }
20464 v.reset(Op386XORLconstmodifyidx4)
20465 v.AuxInt = makeValAndOff(c, off)
20466 v.Aux = sym
20467 v.AddArg(ptr)
20468 v.AddArg(idx)
20469 v.AddArg(mem)
20470 return true
20471 }
20472 return false
20473 }
20474 func rewriteValue386_OpAdd16_0(v *Value) bool {
20475
20476
20477
20478 for {
20479 y := v.Args[1]
20480 x := v.Args[0]
20481 v.reset(Op386ADDL)
20482 v.AddArg(x)
20483 v.AddArg(y)
20484 return true
20485 }
20486 }
20487 func rewriteValue386_OpAdd32_0(v *Value) bool {
20488
20489
20490
20491 for {
20492 y := v.Args[1]
20493 x := v.Args[0]
20494 v.reset(Op386ADDL)
20495 v.AddArg(x)
20496 v.AddArg(y)
20497 return true
20498 }
20499 }
20500 func rewriteValue386_OpAdd32F_0(v *Value) bool {
20501
20502
20503
20504 for {
20505 y := v.Args[1]
20506 x := v.Args[0]
20507 v.reset(Op386ADDSS)
20508 v.AddArg(x)
20509 v.AddArg(y)
20510 return true
20511 }
20512 }
20513 func rewriteValue386_OpAdd32carry_0(v *Value) bool {
20514
20515
20516
20517 for {
20518 y := v.Args[1]
20519 x := v.Args[0]
20520 v.reset(Op386ADDLcarry)
20521 v.AddArg(x)
20522 v.AddArg(y)
20523 return true
20524 }
20525 }
20526 func rewriteValue386_OpAdd32withcarry_0(v *Value) bool {
20527
20528
20529
20530 for {
20531 c := v.Args[2]
20532 x := v.Args[0]
20533 y := v.Args[1]
20534 v.reset(Op386ADCL)
20535 v.AddArg(x)
20536 v.AddArg(y)
20537 v.AddArg(c)
20538 return true
20539 }
20540 }
20541 func rewriteValue386_OpAdd64F_0(v *Value) bool {
20542
20543
20544
20545 for {
20546 y := v.Args[1]
20547 x := v.Args[0]
20548 v.reset(Op386ADDSD)
20549 v.AddArg(x)
20550 v.AddArg(y)
20551 return true
20552 }
20553 }
20554 func rewriteValue386_OpAdd8_0(v *Value) bool {
20555
20556
20557
20558 for {
20559 y := v.Args[1]
20560 x := v.Args[0]
20561 v.reset(Op386ADDL)
20562 v.AddArg(x)
20563 v.AddArg(y)
20564 return true
20565 }
20566 }
20567 func rewriteValue386_OpAddPtr_0(v *Value) bool {
20568
20569
20570
20571 for {
20572 y := v.Args[1]
20573 x := v.Args[0]
20574 v.reset(Op386ADDL)
20575 v.AddArg(x)
20576 v.AddArg(y)
20577 return true
20578 }
20579 }
20580 func rewriteValue386_OpAddr_0(v *Value) bool {
20581
20582
20583
20584 for {
20585 sym := v.Aux
20586 base := v.Args[0]
20587 v.reset(Op386LEAL)
20588 v.Aux = sym
20589 v.AddArg(base)
20590 return true
20591 }
20592 }
20593 func rewriteValue386_OpAnd16_0(v *Value) bool {
20594
20595
20596
20597 for {
20598 y := v.Args[1]
20599 x := v.Args[0]
20600 v.reset(Op386ANDL)
20601 v.AddArg(x)
20602 v.AddArg(y)
20603 return true
20604 }
20605 }
20606 func rewriteValue386_OpAnd32_0(v *Value) bool {
20607
20608
20609
20610 for {
20611 y := v.Args[1]
20612 x := v.Args[0]
20613 v.reset(Op386ANDL)
20614 v.AddArg(x)
20615 v.AddArg(y)
20616 return true
20617 }
20618 }
20619 func rewriteValue386_OpAnd8_0(v *Value) bool {
20620
20621
20622
20623 for {
20624 y := v.Args[1]
20625 x := v.Args[0]
20626 v.reset(Op386ANDL)
20627 v.AddArg(x)
20628 v.AddArg(y)
20629 return true
20630 }
20631 }
20632 func rewriteValue386_OpAndB_0(v *Value) bool {
20633
20634
20635
20636 for {
20637 y := v.Args[1]
20638 x := v.Args[0]
20639 v.reset(Op386ANDL)
20640 v.AddArg(x)
20641 v.AddArg(y)
20642 return true
20643 }
20644 }
20645 func rewriteValue386_OpAvg32u_0(v *Value) bool {
20646
20647
20648
20649 for {
20650 y := v.Args[1]
20651 x := v.Args[0]
20652 v.reset(Op386AVGLU)
20653 v.AddArg(x)
20654 v.AddArg(y)
20655 return true
20656 }
20657 }
20658 func rewriteValue386_OpBswap32_0(v *Value) bool {
20659
20660
20661
20662 for {
20663 x := v.Args[0]
20664 v.reset(Op386BSWAPL)
20665 v.AddArg(x)
20666 return true
20667 }
20668 }
20669 func rewriteValue386_OpClosureCall_0(v *Value) bool {
20670
20671
20672
20673 for {
20674 argwid := v.AuxInt
20675 mem := v.Args[2]
20676 entry := v.Args[0]
20677 closure := v.Args[1]
20678 v.reset(Op386CALLclosure)
20679 v.AuxInt = argwid
20680 v.AddArg(entry)
20681 v.AddArg(closure)
20682 v.AddArg(mem)
20683 return true
20684 }
20685 }
20686 func rewriteValue386_OpCom16_0(v *Value) bool {
20687
20688
20689
20690 for {
20691 x := v.Args[0]
20692 v.reset(Op386NOTL)
20693 v.AddArg(x)
20694 return true
20695 }
20696 }
20697 func rewriteValue386_OpCom32_0(v *Value) bool {
20698
20699
20700
20701 for {
20702 x := v.Args[0]
20703 v.reset(Op386NOTL)
20704 v.AddArg(x)
20705 return true
20706 }
20707 }
20708 func rewriteValue386_OpCom8_0(v *Value) bool {
20709
20710
20711
20712 for {
20713 x := v.Args[0]
20714 v.reset(Op386NOTL)
20715 v.AddArg(x)
20716 return true
20717 }
20718 }
20719 func rewriteValue386_OpConst16_0(v *Value) bool {
20720
20721
20722
20723 for {
20724 val := v.AuxInt
20725 v.reset(Op386MOVLconst)
20726 v.AuxInt = val
20727 return true
20728 }
20729 }
20730 func rewriteValue386_OpConst32_0(v *Value) bool {
20731
20732
20733
20734 for {
20735 val := v.AuxInt
20736 v.reset(Op386MOVLconst)
20737 v.AuxInt = val
20738 return true
20739 }
20740 }
20741 func rewriteValue386_OpConst32F_0(v *Value) bool {
20742
20743
20744
20745 for {
20746 val := v.AuxInt
20747 v.reset(Op386MOVSSconst)
20748 v.AuxInt = val
20749 return true
20750 }
20751 }
20752 func rewriteValue386_OpConst64F_0(v *Value) bool {
20753
20754
20755
20756 for {
20757 val := v.AuxInt
20758 v.reset(Op386MOVSDconst)
20759 v.AuxInt = val
20760 return true
20761 }
20762 }
20763 func rewriteValue386_OpConst8_0(v *Value) bool {
20764
20765
20766
20767 for {
20768 val := v.AuxInt
20769 v.reset(Op386MOVLconst)
20770 v.AuxInt = val
20771 return true
20772 }
20773 }
20774 func rewriteValue386_OpConstBool_0(v *Value) bool {
20775
20776
20777
20778 for {
20779 b := v.AuxInt
20780 v.reset(Op386MOVLconst)
20781 v.AuxInt = b
20782 return true
20783 }
20784 }
20785 func rewriteValue386_OpConstNil_0(v *Value) bool {
20786
20787
20788
20789 for {
20790 v.reset(Op386MOVLconst)
20791 v.AuxInt = 0
20792 return true
20793 }
20794 }
20795 func rewriteValue386_OpCvt32Fto32_0(v *Value) bool {
20796
20797
20798
20799 for {
20800 x := v.Args[0]
20801 v.reset(Op386CVTTSS2SL)
20802 v.AddArg(x)
20803 return true
20804 }
20805 }
20806 func rewriteValue386_OpCvt32Fto64F_0(v *Value) bool {
20807
20808
20809
20810 for {
20811 x := v.Args[0]
20812 v.reset(Op386CVTSS2SD)
20813 v.AddArg(x)
20814 return true
20815 }
20816 }
20817 func rewriteValue386_OpCvt32to32F_0(v *Value) bool {
20818
20819
20820
20821 for {
20822 x := v.Args[0]
20823 v.reset(Op386CVTSL2SS)
20824 v.AddArg(x)
20825 return true
20826 }
20827 }
20828 func rewriteValue386_OpCvt32to64F_0(v *Value) bool {
20829
20830
20831
20832 for {
20833 x := v.Args[0]
20834 v.reset(Op386CVTSL2SD)
20835 v.AddArg(x)
20836 return true
20837 }
20838 }
20839 func rewriteValue386_OpCvt64Fto32_0(v *Value) bool {
20840
20841
20842
20843 for {
20844 x := v.Args[0]
20845 v.reset(Op386CVTTSD2SL)
20846 v.AddArg(x)
20847 return true
20848 }
20849 }
20850 func rewriteValue386_OpCvt64Fto32F_0(v *Value) bool {
20851
20852
20853
20854 for {
20855 x := v.Args[0]
20856 v.reset(Op386CVTSD2SS)
20857 v.AddArg(x)
20858 return true
20859 }
20860 }
20861 func rewriteValue386_OpDiv16_0(v *Value) bool {
20862
20863
20864
20865 for {
20866 a := v.AuxInt
20867 y := v.Args[1]
20868 x := v.Args[0]
20869 v.reset(Op386DIVW)
20870 v.AuxInt = a
20871 v.AddArg(x)
20872 v.AddArg(y)
20873 return true
20874 }
20875 }
20876 func rewriteValue386_OpDiv16u_0(v *Value) bool {
20877
20878
20879
20880 for {
20881 y := v.Args[1]
20882 x := v.Args[0]
20883 v.reset(Op386DIVWU)
20884 v.AddArg(x)
20885 v.AddArg(y)
20886 return true
20887 }
20888 }
20889 func rewriteValue386_OpDiv32_0(v *Value) bool {
20890
20891
20892
20893 for {
20894 a := v.AuxInt
20895 y := v.Args[1]
20896 x := v.Args[0]
20897 v.reset(Op386DIVL)
20898 v.AuxInt = a
20899 v.AddArg(x)
20900 v.AddArg(y)
20901 return true
20902 }
20903 }
20904 func rewriteValue386_OpDiv32F_0(v *Value) bool {
20905
20906
20907
20908 for {
20909 y := v.Args[1]
20910 x := v.Args[0]
20911 v.reset(Op386DIVSS)
20912 v.AddArg(x)
20913 v.AddArg(y)
20914 return true
20915 }
20916 }
20917 func rewriteValue386_OpDiv32u_0(v *Value) bool {
20918
20919
20920
20921 for {
20922 y := v.Args[1]
20923 x := v.Args[0]
20924 v.reset(Op386DIVLU)
20925 v.AddArg(x)
20926 v.AddArg(y)
20927 return true
20928 }
20929 }
20930 func rewriteValue386_OpDiv64F_0(v *Value) bool {
20931
20932
20933
20934 for {
20935 y := v.Args[1]
20936 x := v.Args[0]
20937 v.reset(Op386DIVSD)
20938 v.AddArg(x)
20939 v.AddArg(y)
20940 return true
20941 }
20942 }
20943 func rewriteValue386_OpDiv8_0(v *Value) bool {
20944 b := v.Block
20945 typ := &b.Func.Config.Types
20946
20947
20948
20949 for {
20950 y := v.Args[1]
20951 x := v.Args[0]
20952 v.reset(Op386DIVW)
20953 v0 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16)
20954 v0.AddArg(x)
20955 v.AddArg(v0)
20956 v1 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16)
20957 v1.AddArg(y)
20958 v.AddArg(v1)
20959 return true
20960 }
20961 }
20962 func rewriteValue386_OpDiv8u_0(v *Value) bool {
20963 b := v.Block
20964 typ := &b.Func.Config.Types
20965
20966
20967
20968 for {
20969 y := v.Args[1]
20970 x := v.Args[0]
20971 v.reset(Op386DIVWU)
20972 v0 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16)
20973 v0.AddArg(x)
20974 v.AddArg(v0)
20975 v1 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16)
20976 v1.AddArg(y)
20977 v.AddArg(v1)
20978 return true
20979 }
20980 }
20981 func rewriteValue386_OpEq16_0(v *Value) bool {
20982 b := v.Block
20983
20984
20985
20986 for {
20987 y := v.Args[1]
20988 x := v.Args[0]
20989 v.reset(Op386SETEQ)
20990 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
20991 v0.AddArg(x)
20992 v0.AddArg(y)
20993 v.AddArg(v0)
20994 return true
20995 }
20996 }
20997 func rewriteValue386_OpEq32_0(v *Value) bool {
20998 b := v.Block
20999
21000
21001
21002 for {
21003 y := v.Args[1]
21004 x := v.Args[0]
21005 v.reset(Op386SETEQ)
21006 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21007 v0.AddArg(x)
21008 v0.AddArg(y)
21009 v.AddArg(v0)
21010 return true
21011 }
21012 }
21013 func rewriteValue386_OpEq32F_0(v *Value) bool {
21014 b := v.Block
21015
21016
21017
21018 for {
21019 y := v.Args[1]
21020 x := v.Args[0]
21021 v.reset(Op386SETEQF)
21022 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
21023 v0.AddArg(x)
21024 v0.AddArg(y)
21025 v.AddArg(v0)
21026 return true
21027 }
21028 }
21029 func rewriteValue386_OpEq64F_0(v *Value) bool {
21030 b := v.Block
21031
21032
21033
21034 for {
21035 y := v.Args[1]
21036 x := v.Args[0]
21037 v.reset(Op386SETEQF)
21038 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
21039 v0.AddArg(x)
21040 v0.AddArg(y)
21041 v.AddArg(v0)
21042 return true
21043 }
21044 }
21045 func rewriteValue386_OpEq8_0(v *Value) bool {
21046 b := v.Block
21047
21048
21049
21050 for {
21051 y := v.Args[1]
21052 x := v.Args[0]
21053 v.reset(Op386SETEQ)
21054 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
21055 v0.AddArg(x)
21056 v0.AddArg(y)
21057 v.AddArg(v0)
21058 return true
21059 }
21060 }
21061 func rewriteValue386_OpEqB_0(v *Value) bool {
21062 b := v.Block
21063
21064
21065
21066 for {
21067 y := v.Args[1]
21068 x := v.Args[0]
21069 v.reset(Op386SETEQ)
21070 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
21071 v0.AddArg(x)
21072 v0.AddArg(y)
21073 v.AddArg(v0)
21074 return true
21075 }
21076 }
21077 func rewriteValue386_OpEqPtr_0(v *Value) bool {
21078 b := v.Block
21079
21080
21081
21082 for {
21083 y := v.Args[1]
21084 x := v.Args[0]
21085 v.reset(Op386SETEQ)
21086 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21087 v0.AddArg(x)
21088 v0.AddArg(y)
21089 v.AddArg(v0)
21090 return true
21091 }
21092 }
21093 func rewriteValue386_OpGeq16_0(v *Value) bool {
21094 b := v.Block
21095
21096
21097
21098 for {
21099 y := v.Args[1]
21100 x := v.Args[0]
21101 v.reset(Op386SETGE)
21102 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
21103 v0.AddArg(x)
21104 v0.AddArg(y)
21105 v.AddArg(v0)
21106 return true
21107 }
21108 }
21109 func rewriteValue386_OpGeq16U_0(v *Value) bool {
21110 b := v.Block
21111
21112
21113
21114 for {
21115 y := v.Args[1]
21116 x := v.Args[0]
21117 v.reset(Op386SETAE)
21118 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
21119 v0.AddArg(x)
21120 v0.AddArg(y)
21121 v.AddArg(v0)
21122 return true
21123 }
21124 }
21125 func rewriteValue386_OpGeq32_0(v *Value) bool {
21126 b := v.Block
21127
21128
21129
21130 for {
21131 y := v.Args[1]
21132 x := v.Args[0]
21133 v.reset(Op386SETGE)
21134 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21135 v0.AddArg(x)
21136 v0.AddArg(y)
21137 v.AddArg(v0)
21138 return true
21139 }
21140 }
21141 func rewriteValue386_OpGeq32F_0(v *Value) bool {
21142 b := v.Block
21143
21144
21145
21146 for {
21147 y := v.Args[1]
21148 x := v.Args[0]
21149 v.reset(Op386SETGEF)
21150 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
21151 v0.AddArg(x)
21152 v0.AddArg(y)
21153 v.AddArg(v0)
21154 return true
21155 }
21156 }
21157 func rewriteValue386_OpGeq32U_0(v *Value) bool {
21158 b := v.Block
21159
21160
21161
21162 for {
21163 y := v.Args[1]
21164 x := v.Args[0]
21165 v.reset(Op386SETAE)
21166 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21167 v0.AddArg(x)
21168 v0.AddArg(y)
21169 v.AddArg(v0)
21170 return true
21171 }
21172 }
21173 func rewriteValue386_OpGeq64F_0(v *Value) bool {
21174 b := v.Block
21175
21176
21177
21178 for {
21179 y := v.Args[1]
21180 x := v.Args[0]
21181 v.reset(Op386SETGEF)
21182 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
21183 v0.AddArg(x)
21184 v0.AddArg(y)
21185 v.AddArg(v0)
21186 return true
21187 }
21188 }
21189 func rewriteValue386_OpGeq8_0(v *Value) bool {
21190 b := v.Block
21191
21192
21193
21194 for {
21195 y := v.Args[1]
21196 x := v.Args[0]
21197 v.reset(Op386SETGE)
21198 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
21199 v0.AddArg(x)
21200 v0.AddArg(y)
21201 v.AddArg(v0)
21202 return true
21203 }
21204 }
21205 func rewriteValue386_OpGeq8U_0(v *Value) bool {
21206 b := v.Block
21207
21208
21209
21210 for {
21211 y := v.Args[1]
21212 x := v.Args[0]
21213 v.reset(Op386SETAE)
21214 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
21215 v0.AddArg(x)
21216 v0.AddArg(y)
21217 v.AddArg(v0)
21218 return true
21219 }
21220 }
21221 func rewriteValue386_OpGetCallerPC_0(v *Value) bool {
21222
21223
21224
21225 for {
21226 v.reset(Op386LoweredGetCallerPC)
21227 return true
21228 }
21229 }
21230 func rewriteValue386_OpGetCallerSP_0(v *Value) bool {
21231
21232
21233
21234 for {
21235 v.reset(Op386LoweredGetCallerSP)
21236 return true
21237 }
21238 }
21239 func rewriteValue386_OpGetClosurePtr_0(v *Value) bool {
21240
21241
21242
21243 for {
21244 v.reset(Op386LoweredGetClosurePtr)
21245 return true
21246 }
21247 }
21248 func rewriteValue386_OpGetG_0(v *Value) bool {
21249
21250
21251
21252 for {
21253 mem := v.Args[0]
21254 v.reset(Op386LoweredGetG)
21255 v.AddArg(mem)
21256 return true
21257 }
21258 }
21259 func rewriteValue386_OpGreater16_0(v *Value) bool {
21260 b := v.Block
21261
21262
21263
21264 for {
21265 y := v.Args[1]
21266 x := v.Args[0]
21267 v.reset(Op386SETG)
21268 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
21269 v0.AddArg(x)
21270 v0.AddArg(y)
21271 v.AddArg(v0)
21272 return true
21273 }
21274 }
21275 func rewriteValue386_OpGreater16U_0(v *Value) bool {
21276 b := v.Block
21277
21278
21279
21280 for {
21281 y := v.Args[1]
21282 x := v.Args[0]
21283 v.reset(Op386SETA)
21284 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
21285 v0.AddArg(x)
21286 v0.AddArg(y)
21287 v.AddArg(v0)
21288 return true
21289 }
21290 }
21291 func rewriteValue386_OpGreater32_0(v *Value) bool {
21292 b := v.Block
21293
21294
21295
21296 for {
21297 y := v.Args[1]
21298 x := v.Args[0]
21299 v.reset(Op386SETG)
21300 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21301 v0.AddArg(x)
21302 v0.AddArg(y)
21303 v.AddArg(v0)
21304 return true
21305 }
21306 }
21307 func rewriteValue386_OpGreater32F_0(v *Value) bool {
21308 b := v.Block
21309
21310
21311
21312 for {
21313 y := v.Args[1]
21314 x := v.Args[0]
21315 v.reset(Op386SETGF)
21316 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
21317 v0.AddArg(x)
21318 v0.AddArg(y)
21319 v.AddArg(v0)
21320 return true
21321 }
21322 }
21323 func rewriteValue386_OpGreater32U_0(v *Value) bool {
21324 b := v.Block
21325
21326
21327
21328 for {
21329 y := v.Args[1]
21330 x := v.Args[0]
21331 v.reset(Op386SETA)
21332 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21333 v0.AddArg(x)
21334 v0.AddArg(y)
21335 v.AddArg(v0)
21336 return true
21337 }
21338 }
21339 func rewriteValue386_OpGreater64F_0(v *Value) bool {
21340 b := v.Block
21341
21342
21343
21344 for {
21345 y := v.Args[1]
21346 x := v.Args[0]
21347 v.reset(Op386SETGF)
21348 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
21349 v0.AddArg(x)
21350 v0.AddArg(y)
21351 v.AddArg(v0)
21352 return true
21353 }
21354 }
21355 func rewriteValue386_OpGreater8_0(v *Value) bool {
21356 b := v.Block
21357
21358
21359
21360 for {
21361 y := v.Args[1]
21362 x := v.Args[0]
21363 v.reset(Op386SETG)
21364 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
21365 v0.AddArg(x)
21366 v0.AddArg(y)
21367 v.AddArg(v0)
21368 return true
21369 }
21370 }
21371 func rewriteValue386_OpGreater8U_0(v *Value) bool {
21372 b := v.Block
21373
21374
21375
21376 for {
21377 y := v.Args[1]
21378 x := v.Args[0]
21379 v.reset(Op386SETA)
21380 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
21381 v0.AddArg(x)
21382 v0.AddArg(y)
21383 v.AddArg(v0)
21384 return true
21385 }
21386 }
21387 func rewriteValue386_OpHmul32_0(v *Value) bool {
21388
21389
21390
21391 for {
21392 y := v.Args[1]
21393 x := v.Args[0]
21394 v.reset(Op386HMULL)
21395 v.AddArg(x)
21396 v.AddArg(y)
21397 return true
21398 }
21399 }
21400 func rewriteValue386_OpHmul32u_0(v *Value) bool {
21401
21402
21403
21404 for {
21405 y := v.Args[1]
21406 x := v.Args[0]
21407 v.reset(Op386HMULLU)
21408 v.AddArg(x)
21409 v.AddArg(y)
21410 return true
21411 }
21412 }
21413 func rewriteValue386_OpInterCall_0(v *Value) bool {
21414
21415
21416
21417 for {
21418 argwid := v.AuxInt
21419 mem := v.Args[1]
21420 entry := v.Args[0]
21421 v.reset(Op386CALLinter)
21422 v.AuxInt = argwid
21423 v.AddArg(entry)
21424 v.AddArg(mem)
21425 return true
21426 }
21427 }
21428 func rewriteValue386_OpIsInBounds_0(v *Value) bool {
21429 b := v.Block
21430
21431
21432
21433 for {
21434 len := v.Args[1]
21435 idx := v.Args[0]
21436 v.reset(Op386SETB)
21437 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21438 v0.AddArg(idx)
21439 v0.AddArg(len)
21440 v.AddArg(v0)
21441 return true
21442 }
21443 }
21444 func rewriteValue386_OpIsNonNil_0(v *Value) bool {
21445 b := v.Block
21446
21447
21448
21449 for {
21450 p := v.Args[0]
21451 v.reset(Op386SETNE)
21452 v0 := b.NewValue0(v.Pos, Op386TESTL, types.TypeFlags)
21453 v0.AddArg(p)
21454 v0.AddArg(p)
21455 v.AddArg(v0)
21456 return true
21457 }
21458 }
21459 func rewriteValue386_OpIsSliceInBounds_0(v *Value) bool {
21460 b := v.Block
21461
21462
21463
21464 for {
21465 len := v.Args[1]
21466 idx := v.Args[0]
21467 v.reset(Op386SETBE)
21468 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21469 v0.AddArg(idx)
21470 v0.AddArg(len)
21471 v.AddArg(v0)
21472 return true
21473 }
21474 }
21475 func rewriteValue386_OpLeq16_0(v *Value) bool {
21476 b := v.Block
21477
21478
21479
21480 for {
21481 y := v.Args[1]
21482 x := v.Args[0]
21483 v.reset(Op386SETLE)
21484 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
21485 v0.AddArg(x)
21486 v0.AddArg(y)
21487 v.AddArg(v0)
21488 return true
21489 }
21490 }
21491 func rewriteValue386_OpLeq16U_0(v *Value) bool {
21492 b := v.Block
21493
21494
21495
21496 for {
21497 y := v.Args[1]
21498 x := v.Args[0]
21499 v.reset(Op386SETBE)
21500 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
21501 v0.AddArg(x)
21502 v0.AddArg(y)
21503 v.AddArg(v0)
21504 return true
21505 }
21506 }
21507 func rewriteValue386_OpLeq32_0(v *Value) bool {
21508 b := v.Block
21509
21510
21511
21512 for {
21513 y := v.Args[1]
21514 x := v.Args[0]
21515 v.reset(Op386SETLE)
21516 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21517 v0.AddArg(x)
21518 v0.AddArg(y)
21519 v.AddArg(v0)
21520 return true
21521 }
21522 }
21523 func rewriteValue386_OpLeq32F_0(v *Value) bool {
21524 b := v.Block
21525
21526
21527
21528 for {
21529 y := v.Args[1]
21530 x := v.Args[0]
21531 v.reset(Op386SETGEF)
21532 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
21533 v0.AddArg(y)
21534 v0.AddArg(x)
21535 v.AddArg(v0)
21536 return true
21537 }
21538 }
21539 func rewriteValue386_OpLeq32U_0(v *Value) bool {
21540 b := v.Block
21541
21542
21543
21544 for {
21545 y := v.Args[1]
21546 x := v.Args[0]
21547 v.reset(Op386SETBE)
21548 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21549 v0.AddArg(x)
21550 v0.AddArg(y)
21551 v.AddArg(v0)
21552 return true
21553 }
21554 }
21555 func rewriteValue386_OpLeq64F_0(v *Value) bool {
21556 b := v.Block
21557
21558
21559
21560 for {
21561 y := v.Args[1]
21562 x := v.Args[0]
21563 v.reset(Op386SETGEF)
21564 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
21565 v0.AddArg(y)
21566 v0.AddArg(x)
21567 v.AddArg(v0)
21568 return true
21569 }
21570 }
21571 func rewriteValue386_OpLeq8_0(v *Value) bool {
21572 b := v.Block
21573
21574
21575
21576 for {
21577 y := v.Args[1]
21578 x := v.Args[0]
21579 v.reset(Op386SETLE)
21580 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
21581 v0.AddArg(x)
21582 v0.AddArg(y)
21583 v.AddArg(v0)
21584 return true
21585 }
21586 }
21587 func rewriteValue386_OpLeq8U_0(v *Value) bool {
21588 b := v.Block
21589
21590
21591
21592 for {
21593 y := v.Args[1]
21594 x := v.Args[0]
21595 v.reset(Op386SETBE)
21596 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
21597 v0.AddArg(x)
21598 v0.AddArg(y)
21599 v.AddArg(v0)
21600 return true
21601 }
21602 }
21603 func rewriteValue386_OpLess16_0(v *Value) bool {
21604 b := v.Block
21605
21606
21607
21608 for {
21609 y := v.Args[1]
21610 x := v.Args[0]
21611 v.reset(Op386SETL)
21612 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
21613 v0.AddArg(x)
21614 v0.AddArg(y)
21615 v.AddArg(v0)
21616 return true
21617 }
21618 }
21619 func rewriteValue386_OpLess16U_0(v *Value) bool {
21620 b := v.Block
21621
21622
21623
21624 for {
21625 y := v.Args[1]
21626 x := v.Args[0]
21627 v.reset(Op386SETB)
21628 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
21629 v0.AddArg(x)
21630 v0.AddArg(y)
21631 v.AddArg(v0)
21632 return true
21633 }
21634 }
21635 func rewriteValue386_OpLess32_0(v *Value) bool {
21636 b := v.Block
21637
21638
21639
21640 for {
21641 y := v.Args[1]
21642 x := v.Args[0]
21643 v.reset(Op386SETL)
21644 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21645 v0.AddArg(x)
21646 v0.AddArg(y)
21647 v.AddArg(v0)
21648 return true
21649 }
21650 }
21651 func rewriteValue386_OpLess32F_0(v *Value) bool {
21652 b := v.Block
21653
21654
21655
21656 for {
21657 y := v.Args[1]
21658 x := v.Args[0]
21659 v.reset(Op386SETGF)
21660 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
21661 v0.AddArg(y)
21662 v0.AddArg(x)
21663 v.AddArg(v0)
21664 return true
21665 }
21666 }
21667 func rewriteValue386_OpLess32U_0(v *Value) bool {
21668 b := v.Block
21669
21670
21671
21672 for {
21673 y := v.Args[1]
21674 x := v.Args[0]
21675 v.reset(Op386SETB)
21676 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
21677 v0.AddArg(x)
21678 v0.AddArg(y)
21679 v.AddArg(v0)
21680 return true
21681 }
21682 }
21683 func rewriteValue386_OpLess64F_0(v *Value) bool {
21684 b := v.Block
21685
21686
21687
21688 for {
21689 y := v.Args[1]
21690 x := v.Args[0]
21691 v.reset(Op386SETGF)
21692 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
21693 v0.AddArg(y)
21694 v0.AddArg(x)
21695 v.AddArg(v0)
21696 return true
21697 }
21698 }
21699 func rewriteValue386_OpLess8_0(v *Value) bool {
21700 b := v.Block
21701
21702
21703
21704 for {
21705 y := v.Args[1]
21706 x := v.Args[0]
21707 v.reset(Op386SETL)
21708 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
21709 v0.AddArg(x)
21710 v0.AddArg(y)
21711 v.AddArg(v0)
21712 return true
21713 }
21714 }
21715 func rewriteValue386_OpLess8U_0(v *Value) bool {
21716 b := v.Block
21717
21718
21719
21720 for {
21721 y := v.Args[1]
21722 x := v.Args[0]
21723 v.reset(Op386SETB)
21724 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
21725 v0.AddArg(x)
21726 v0.AddArg(y)
21727 v.AddArg(v0)
21728 return true
21729 }
21730 }
21731 func rewriteValue386_OpLoad_0(v *Value) bool {
21732
21733
21734
21735 for {
21736 t := v.Type
21737 mem := v.Args[1]
21738 ptr := v.Args[0]
21739 if !(is32BitInt(t) || isPtr(t)) {
21740 break
21741 }
21742 v.reset(Op386MOVLload)
21743 v.AddArg(ptr)
21744 v.AddArg(mem)
21745 return true
21746 }
21747
21748
21749
21750 for {
21751 t := v.Type
21752 mem := v.Args[1]
21753 ptr := v.Args[0]
21754 if !(is16BitInt(t)) {
21755 break
21756 }
21757 v.reset(Op386MOVWload)
21758 v.AddArg(ptr)
21759 v.AddArg(mem)
21760 return true
21761 }
21762
21763
21764
21765 for {
21766 t := v.Type
21767 mem := v.Args[1]
21768 ptr := v.Args[0]
21769 if !(t.IsBoolean() || is8BitInt(t)) {
21770 break
21771 }
21772 v.reset(Op386MOVBload)
21773 v.AddArg(ptr)
21774 v.AddArg(mem)
21775 return true
21776 }
21777
21778
21779
21780 for {
21781 t := v.Type
21782 mem := v.Args[1]
21783 ptr := v.Args[0]
21784 if !(is32BitFloat(t)) {
21785 break
21786 }
21787 v.reset(Op386MOVSSload)
21788 v.AddArg(ptr)
21789 v.AddArg(mem)
21790 return true
21791 }
21792
21793
21794
21795 for {
21796 t := v.Type
21797 mem := v.Args[1]
21798 ptr := v.Args[0]
21799 if !(is64BitFloat(t)) {
21800 break
21801 }
21802 v.reset(Op386MOVSDload)
21803 v.AddArg(ptr)
21804 v.AddArg(mem)
21805 return true
21806 }
21807 return false
21808 }
21809 func rewriteValue386_OpLocalAddr_0(v *Value) bool {
21810
21811
21812
21813 for {
21814 sym := v.Aux
21815 _ = v.Args[1]
21816 base := v.Args[0]
21817 v.reset(Op386LEAL)
21818 v.Aux = sym
21819 v.AddArg(base)
21820 return true
21821 }
21822 }
21823 func rewriteValue386_OpLsh16x16_0(v *Value) bool {
21824 b := v.Block
21825
21826
21827
21828 for {
21829 t := v.Type
21830 y := v.Args[1]
21831 x := v.Args[0]
21832 v.reset(Op386ANDL)
21833 v0 := b.NewValue0(v.Pos, Op386SHLL, t)
21834 v0.AddArg(x)
21835 v0.AddArg(y)
21836 v.AddArg(v0)
21837 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
21838 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
21839 v2.AuxInt = 32
21840 v2.AddArg(y)
21841 v1.AddArg(v2)
21842 v.AddArg(v1)
21843 return true
21844 }
21845 }
21846 func rewriteValue386_OpLsh16x32_0(v *Value) bool {
21847 b := v.Block
21848
21849
21850
21851 for {
21852 t := v.Type
21853 y := v.Args[1]
21854 x := v.Args[0]
21855 v.reset(Op386ANDL)
21856 v0 := b.NewValue0(v.Pos, Op386SHLL, t)
21857 v0.AddArg(x)
21858 v0.AddArg(y)
21859 v.AddArg(v0)
21860 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
21861 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
21862 v2.AuxInt = 32
21863 v2.AddArg(y)
21864 v1.AddArg(v2)
21865 v.AddArg(v1)
21866 return true
21867 }
21868 }
21869 func rewriteValue386_OpLsh16x64_0(v *Value) bool {
21870
21871
21872
21873 for {
21874 _ = v.Args[1]
21875 x := v.Args[0]
21876 v_1 := v.Args[1]
21877 if v_1.Op != OpConst64 {
21878 break
21879 }
21880 c := v_1.AuxInt
21881 if !(uint64(c) < 16) {
21882 break
21883 }
21884 v.reset(Op386SHLLconst)
21885 v.AuxInt = c
21886 v.AddArg(x)
21887 return true
21888 }
21889
21890
21891
21892 for {
21893 _ = v.Args[1]
21894 v_1 := v.Args[1]
21895 if v_1.Op != OpConst64 {
21896 break
21897 }
21898 c := v_1.AuxInt
21899 if !(uint64(c) >= 16) {
21900 break
21901 }
21902 v.reset(OpConst16)
21903 v.AuxInt = 0
21904 return true
21905 }
21906 return false
21907 }
21908 func rewriteValue386_OpLsh16x8_0(v *Value) bool {
21909 b := v.Block
21910
21911
21912
21913 for {
21914 t := v.Type
21915 y := v.Args[1]
21916 x := v.Args[0]
21917 v.reset(Op386ANDL)
21918 v0 := b.NewValue0(v.Pos, Op386SHLL, t)
21919 v0.AddArg(x)
21920 v0.AddArg(y)
21921 v.AddArg(v0)
21922 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
21923 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
21924 v2.AuxInt = 32
21925 v2.AddArg(y)
21926 v1.AddArg(v2)
21927 v.AddArg(v1)
21928 return true
21929 }
21930 }
21931 func rewriteValue386_OpLsh32x16_0(v *Value) bool {
21932 b := v.Block
21933
21934
21935
21936 for {
21937 t := v.Type
21938 y := v.Args[1]
21939 x := v.Args[0]
21940 v.reset(Op386ANDL)
21941 v0 := b.NewValue0(v.Pos, Op386SHLL, t)
21942 v0.AddArg(x)
21943 v0.AddArg(y)
21944 v.AddArg(v0)
21945 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
21946 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
21947 v2.AuxInt = 32
21948 v2.AddArg(y)
21949 v1.AddArg(v2)
21950 v.AddArg(v1)
21951 return true
21952 }
21953 }
21954 func rewriteValue386_OpLsh32x32_0(v *Value) bool {
21955 b := v.Block
21956
21957
21958
21959 for {
21960 t := v.Type
21961 y := v.Args[1]
21962 x := v.Args[0]
21963 v.reset(Op386ANDL)
21964 v0 := b.NewValue0(v.Pos, Op386SHLL, t)
21965 v0.AddArg(x)
21966 v0.AddArg(y)
21967 v.AddArg(v0)
21968 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
21969 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
21970 v2.AuxInt = 32
21971 v2.AddArg(y)
21972 v1.AddArg(v2)
21973 v.AddArg(v1)
21974 return true
21975 }
21976 }
21977 func rewriteValue386_OpLsh32x64_0(v *Value) bool {
21978
21979
21980
21981 for {
21982 _ = v.Args[1]
21983 x := v.Args[0]
21984 v_1 := v.Args[1]
21985 if v_1.Op != OpConst64 {
21986 break
21987 }
21988 c := v_1.AuxInt
21989 if !(uint64(c) < 32) {
21990 break
21991 }
21992 v.reset(Op386SHLLconst)
21993 v.AuxInt = c
21994 v.AddArg(x)
21995 return true
21996 }
21997
21998
21999
22000 for {
22001 _ = v.Args[1]
22002 v_1 := v.Args[1]
22003 if v_1.Op != OpConst64 {
22004 break
22005 }
22006 c := v_1.AuxInt
22007 if !(uint64(c) >= 32) {
22008 break
22009 }
22010 v.reset(OpConst32)
22011 v.AuxInt = 0
22012 return true
22013 }
22014 return false
22015 }
22016 func rewriteValue386_OpLsh32x8_0(v *Value) bool {
22017 b := v.Block
22018
22019
22020
22021 for {
22022 t := v.Type
22023 y := v.Args[1]
22024 x := v.Args[0]
22025 v.reset(Op386ANDL)
22026 v0 := b.NewValue0(v.Pos, Op386SHLL, t)
22027 v0.AddArg(x)
22028 v0.AddArg(y)
22029 v.AddArg(v0)
22030 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
22031 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
22032 v2.AuxInt = 32
22033 v2.AddArg(y)
22034 v1.AddArg(v2)
22035 v.AddArg(v1)
22036 return true
22037 }
22038 }
22039 func rewriteValue386_OpLsh8x16_0(v *Value) bool {
22040 b := v.Block
22041
22042
22043
22044 for {
22045 t := v.Type
22046 y := v.Args[1]
22047 x := v.Args[0]
22048 v.reset(Op386ANDL)
22049 v0 := b.NewValue0(v.Pos, Op386SHLL, t)
22050 v0.AddArg(x)
22051 v0.AddArg(y)
22052 v.AddArg(v0)
22053 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
22054 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
22055 v2.AuxInt = 32
22056 v2.AddArg(y)
22057 v1.AddArg(v2)
22058 v.AddArg(v1)
22059 return true
22060 }
22061 }
22062 func rewriteValue386_OpLsh8x32_0(v *Value) bool {
22063 b := v.Block
22064
22065
22066
22067 for {
22068 t := v.Type
22069 y := v.Args[1]
22070 x := v.Args[0]
22071 v.reset(Op386ANDL)
22072 v0 := b.NewValue0(v.Pos, Op386SHLL, t)
22073 v0.AddArg(x)
22074 v0.AddArg(y)
22075 v.AddArg(v0)
22076 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
22077 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
22078 v2.AuxInt = 32
22079 v2.AddArg(y)
22080 v1.AddArg(v2)
22081 v.AddArg(v1)
22082 return true
22083 }
22084 }
22085 func rewriteValue386_OpLsh8x64_0(v *Value) bool {
22086
22087
22088
22089 for {
22090 _ = v.Args[1]
22091 x := v.Args[0]
22092 v_1 := v.Args[1]
22093 if v_1.Op != OpConst64 {
22094 break
22095 }
22096 c := v_1.AuxInt
22097 if !(uint64(c) < 8) {
22098 break
22099 }
22100 v.reset(Op386SHLLconst)
22101 v.AuxInt = c
22102 v.AddArg(x)
22103 return true
22104 }
22105
22106
22107
22108 for {
22109 _ = v.Args[1]
22110 v_1 := v.Args[1]
22111 if v_1.Op != OpConst64 {
22112 break
22113 }
22114 c := v_1.AuxInt
22115 if !(uint64(c) >= 8) {
22116 break
22117 }
22118 v.reset(OpConst8)
22119 v.AuxInt = 0
22120 return true
22121 }
22122 return false
22123 }
22124 func rewriteValue386_OpLsh8x8_0(v *Value) bool {
22125 b := v.Block
22126
22127
22128
22129 for {
22130 t := v.Type
22131 y := v.Args[1]
22132 x := v.Args[0]
22133 v.reset(Op386ANDL)
22134 v0 := b.NewValue0(v.Pos, Op386SHLL, t)
22135 v0.AddArg(x)
22136 v0.AddArg(y)
22137 v.AddArg(v0)
22138 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
22139 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
22140 v2.AuxInt = 32
22141 v2.AddArg(y)
22142 v1.AddArg(v2)
22143 v.AddArg(v1)
22144 return true
22145 }
22146 }
22147 func rewriteValue386_OpMod16_0(v *Value) bool {
22148
22149
22150
22151 for {
22152 a := v.AuxInt
22153 y := v.Args[1]
22154 x := v.Args[0]
22155 v.reset(Op386MODW)
22156 v.AuxInt = a
22157 v.AddArg(x)
22158 v.AddArg(y)
22159 return true
22160 }
22161 }
22162 func rewriteValue386_OpMod16u_0(v *Value) bool {
22163
22164
22165
22166 for {
22167 y := v.Args[1]
22168 x := v.Args[0]
22169 v.reset(Op386MODWU)
22170 v.AddArg(x)
22171 v.AddArg(y)
22172 return true
22173 }
22174 }
22175 func rewriteValue386_OpMod32_0(v *Value) bool {
22176
22177
22178
22179 for {
22180 a := v.AuxInt
22181 y := v.Args[1]
22182 x := v.Args[0]
22183 v.reset(Op386MODL)
22184 v.AuxInt = a
22185 v.AddArg(x)
22186 v.AddArg(y)
22187 return true
22188 }
22189 }
22190 func rewriteValue386_OpMod32u_0(v *Value) bool {
22191
22192
22193
22194 for {
22195 y := v.Args[1]
22196 x := v.Args[0]
22197 v.reset(Op386MODLU)
22198 v.AddArg(x)
22199 v.AddArg(y)
22200 return true
22201 }
22202 }
22203 func rewriteValue386_OpMod8_0(v *Value) bool {
22204 b := v.Block
22205 typ := &b.Func.Config.Types
22206
22207
22208
22209 for {
22210 y := v.Args[1]
22211 x := v.Args[0]
22212 v.reset(Op386MODW)
22213 v0 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16)
22214 v0.AddArg(x)
22215 v.AddArg(v0)
22216 v1 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16)
22217 v1.AddArg(y)
22218 v.AddArg(v1)
22219 return true
22220 }
22221 }
22222 func rewriteValue386_OpMod8u_0(v *Value) bool {
22223 b := v.Block
22224 typ := &b.Func.Config.Types
22225
22226
22227
22228 for {
22229 y := v.Args[1]
22230 x := v.Args[0]
22231 v.reset(Op386MODWU)
22232 v0 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16)
22233 v0.AddArg(x)
22234 v.AddArg(v0)
22235 v1 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16)
22236 v1.AddArg(y)
22237 v.AddArg(v1)
22238 return true
22239 }
22240 }
22241 func rewriteValue386_OpMove_0(v *Value) bool {
22242 b := v.Block
22243 typ := &b.Func.Config.Types
22244
22245
22246
22247 for {
22248 if v.AuxInt != 0 {
22249 break
22250 }
22251 mem := v.Args[2]
22252 v.reset(OpCopy)
22253 v.Type = mem.Type
22254 v.AddArg(mem)
22255 return true
22256 }
22257
22258
22259
22260 for {
22261 if v.AuxInt != 1 {
22262 break
22263 }
22264 mem := v.Args[2]
22265 dst := v.Args[0]
22266 src := v.Args[1]
22267 v.reset(Op386MOVBstore)
22268 v.AddArg(dst)
22269 v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8)
22270 v0.AddArg(src)
22271 v0.AddArg(mem)
22272 v.AddArg(v0)
22273 v.AddArg(mem)
22274 return true
22275 }
22276
22277
22278
22279 for {
22280 if v.AuxInt != 2 {
22281 break
22282 }
22283 mem := v.Args[2]
22284 dst := v.Args[0]
22285 src := v.Args[1]
22286 v.reset(Op386MOVWstore)
22287 v.AddArg(dst)
22288 v0 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16)
22289 v0.AddArg(src)
22290 v0.AddArg(mem)
22291 v.AddArg(v0)
22292 v.AddArg(mem)
22293 return true
22294 }
22295
22296
22297
22298 for {
22299 if v.AuxInt != 4 {
22300 break
22301 }
22302 mem := v.Args[2]
22303 dst := v.Args[0]
22304 src := v.Args[1]
22305 v.reset(Op386MOVLstore)
22306 v.AddArg(dst)
22307 v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
22308 v0.AddArg(src)
22309 v0.AddArg(mem)
22310 v.AddArg(v0)
22311 v.AddArg(mem)
22312 return true
22313 }
22314
22315
22316
22317 for {
22318 if v.AuxInt != 3 {
22319 break
22320 }
22321 mem := v.Args[2]
22322 dst := v.Args[0]
22323 src := v.Args[1]
22324 v.reset(Op386MOVBstore)
22325 v.AuxInt = 2
22326 v.AddArg(dst)
22327 v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8)
22328 v0.AuxInt = 2
22329 v0.AddArg(src)
22330 v0.AddArg(mem)
22331 v.AddArg(v0)
22332 v1 := b.NewValue0(v.Pos, Op386MOVWstore, types.TypeMem)
22333 v1.AddArg(dst)
22334 v2 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16)
22335 v2.AddArg(src)
22336 v2.AddArg(mem)
22337 v1.AddArg(v2)
22338 v1.AddArg(mem)
22339 v.AddArg(v1)
22340 return true
22341 }
22342
22343
22344
22345 for {
22346 if v.AuxInt != 5 {
22347 break
22348 }
22349 mem := v.Args[2]
22350 dst := v.Args[0]
22351 src := v.Args[1]
22352 v.reset(Op386MOVBstore)
22353 v.AuxInt = 4
22354 v.AddArg(dst)
22355 v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8)
22356 v0.AuxInt = 4
22357 v0.AddArg(src)
22358 v0.AddArg(mem)
22359 v.AddArg(v0)
22360 v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem)
22361 v1.AddArg(dst)
22362 v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
22363 v2.AddArg(src)
22364 v2.AddArg(mem)
22365 v1.AddArg(v2)
22366 v1.AddArg(mem)
22367 v.AddArg(v1)
22368 return true
22369 }
22370
22371
22372
22373 for {
22374 if v.AuxInt != 6 {
22375 break
22376 }
22377 mem := v.Args[2]
22378 dst := v.Args[0]
22379 src := v.Args[1]
22380 v.reset(Op386MOVWstore)
22381 v.AuxInt = 4
22382 v.AddArg(dst)
22383 v0 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16)
22384 v0.AuxInt = 4
22385 v0.AddArg(src)
22386 v0.AddArg(mem)
22387 v.AddArg(v0)
22388 v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem)
22389 v1.AddArg(dst)
22390 v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
22391 v2.AddArg(src)
22392 v2.AddArg(mem)
22393 v1.AddArg(v2)
22394 v1.AddArg(mem)
22395 v.AddArg(v1)
22396 return true
22397 }
22398
22399
22400
22401 for {
22402 if v.AuxInt != 7 {
22403 break
22404 }
22405 mem := v.Args[2]
22406 dst := v.Args[0]
22407 src := v.Args[1]
22408 v.reset(Op386MOVLstore)
22409 v.AuxInt = 3
22410 v.AddArg(dst)
22411 v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
22412 v0.AuxInt = 3
22413 v0.AddArg(src)
22414 v0.AddArg(mem)
22415 v.AddArg(v0)
22416 v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem)
22417 v1.AddArg(dst)
22418 v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
22419 v2.AddArg(src)
22420 v2.AddArg(mem)
22421 v1.AddArg(v2)
22422 v1.AddArg(mem)
22423 v.AddArg(v1)
22424 return true
22425 }
22426
22427
22428
22429 for {
22430 if v.AuxInt != 8 {
22431 break
22432 }
22433 mem := v.Args[2]
22434 dst := v.Args[0]
22435 src := v.Args[1]
22436 v.reset(Op386MOVLstore)
22437 v.AuxInt = 4
22438 v.AddArg(dst)
22439 v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
22440 v0.AuxInt = 4
22441 v0.AddArg(src)
22442 v0.AddArg(mem)
22443 v.AddArg(v0)
22444 v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem)
22445 v1.AddArg(dst)
22446 v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
22447 v2.AddArg(src)
22448 v2.AddArg(mem)
22449 v1.AddArg(v2)
22450 v1.AddArg(mem)
22451 v.AddArg(v1)
22452 return true
22453 }
22454
22455
22456
22457 for {
22458 s := v.AuxInt
22459 mem := v.Args[2]
22460 dst := v.Args[0]
22461 src := v.Args[1]
22462 if !(s > 8 && s%4 != 0) {
22463 break
22464 }
22465 v.reset(OpMove)
22466 v.AuxInt = s - s%4
22467 v0 := b.NewValue0(v.Pos, Op386ADDLconst, dst.Type)
22468 v0.AuxInt = s % 4
22469 v0.AddArg(dst)
22470 v.AddArg(v0)
22471 v1 := b.NewValue0(v.Pos, Op386ADDLconst, src.Type)
22472 v1.AuxInt = s % 4
22473 v1.AddArg(src)
22474 v.AddArg(v1)
22475 v2 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem)
22476 v2.AddArg(dst)
22477 v3 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
22478 v3.AddArg(src)
22479 v3.AddArg(mem)
22480 v2.AddArg(v3)
22481 v2.AddArg(mem)
22482 v.AddArg(v2)
22483 return true
22484 }
22485 return false
22486 }
22487 func rewriteValue386_OpMove_10(v *Value) bool {
22488 b := v.Block
22489 config := b.Func.Config
22490 typ := &b.Func.Config.Types
22491
22492
22493
22494 for {
22495 s := v.AuxInt
22496 mem := v.Args[2]
22497 dst := v.Args[0]
22498 src := v.Args[1]
22499 if !(s > 8 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice) {
22500 break
22501 }
22502 v.reset(Op386DUFFCOPY)
22503 v.AuxInt = 10 * (128 - s/4)
22504 v.AddArg(dst)
22505 v.AddArg(src)
22506 v.AddArg(mem)
22507 return true
22508 }
22509
22510
22511
22512 for {
22513 s := v.AuxInt
22514 mem := v.Args[2]
22515 dst := v.Args[0]
22516 src := v.Args[1]
22517 if !((s > 4*128 || config.noDuffDevice) && s%4 == 0) {
22518 break
22519 }
22520 v.reset(Op386REPMOVSL)
22521 v.AddArg(dst)
22522 v.AddArg(src)
22523 v0 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32)
22524 v0.AuxInt = s / 4
22525 v.AddArg(v0)
22526 v.AddArg(mem)
22527 return true
22528 }
22529 return false
22530 }
22531 func rewriteValue386_OpMul16_0(v *Value) bool {
22532
22533
22534
22535 for {
22536 y := v.Args[1]
22537 x := v.Args[0]
22538 v.reset(Op386MULL)
22539 v.AddArg(x)
22540 v.AddArg(y)
22541 return true
22542 }
22543 }
22544 func rewriteValue386_OpMul32_0(v *Value) bool {
22545
22546
22547
22548 for {
22549 y := v.Args[1]
22550 x := v.Args[0]
22551 v.reset(Op386MULL)
22552 v.AddArg(x)
22553 v.AddArg(y)
22554 return true
22555 }
22556 }
22557 func rewriteValue386_OpMul32F_0(v *Value) bool {
22558
22559
22560
22561 for {
22562 y := v.Args[1]
22563 x := v.Args[0]
22564 v.reset(Op386MULSS)
22565 v.AddArg(x)
22566 v.AddArg(y)
22567 return true
22568 }
22569 }
22570 func rewriteValue386_OpMul32uhilo_0(v *Value) bool {
22571
22572
22573
22574 for {
22575 y := v.Args[1]
22576 x := v.Args[0]
22577 v.reset(Op386MULLQU)
22578 v.AddArg(x)
22579 v.AddArg(y)
22580 return true
22581 }
22582 }
22583 func rewriteValue386_OpMul64F_0(v *Value) bool {
22584
22585
22586
22587 for {
22588 y := v.Args[1]
22589 x := v.Args[0]
22590 v.reset(Op386MULSD)
22591 v.AddArg(x)
22592 v.AddArg(y)
22593 return true
22594 }
22595 }
22596 func rewriteValue386_OpMul8_0(v *Value) bool {
22597
22598
22599
22600 for {
22601 y := v.Args[1]
22602 x := v.Args[0]
22603 v.reset(Op386MULL)
22604 v.AddArg(x)
22605 v.AddArg(y)
22606 return true
22607 }
22608 }
22609 func rewriteValue386_OpNeg16_0(v *Value) bool {
22610
22611
22612
22613 for {
22614 x := v.Args[0]
22615 v.reset(Op386NEGL)
22616 v.AddArg(x)
22617 return true
22618 }
22619 }
22620 func rewriteValue386_OpNeg32_0(v *Value) bool {
22621
22622
22623
22624 for {
22625 x := v.Args[0]
22626 v.reset(Op386NEGL)
22627 v.AddArg(x)
22628 return true
22629 }
22630 }
22631 func rewriteValue386_OpNeg32F_0(v *Value) bool {
22632 b := v.Block
22633 config := b.Func.Config
22634 typ := &b.Func.Config.Types
22635
22636
22637
22638 for {
22639 x := v.Args[0]
22640 if !(!config.use387) {
22641 break
22642 }
22643 v.reset(Op386PXOR)
22644 v.AddArg(x)
22645 v0 := b.NewValue0(v.Pos, Op386MOVSSconst, typ.Float32)
22646 v0.AuxInt = auxFrom32F(float32(math.Copysign(0, -1)))
22647 v.AddArg(v0)
22648 return true
22649 }
22650
22651
22652
22653 for {
22654 x := v.Args[0]
22655 if !(config.use387) {
22656 break
22657 }
22658 v.reset(Op386FCHS)
22659 v.AddArg(x)
22660 return true
22661 }
22662 return false
22663 }
22664 func rewriteValue386_OpNeg64F_0(v *Value) bool {
22665 b := v.Block
22666 config := b.Func.Config
22667 typ := &b.Func.Config.Types
22668
22669
22670
22671 for {
22672 x := v.Args[0]
22673 if !(!config.use387) {
22674 break
22675 }
22676 v.reset(Op386PXOR)
22677 v.AddArg(x)
22678 v0 := b.NewValue0(v.Pos, Op386MOVSDconst, typ.Float64)
22679 v0.AuxInt = auxFrom64F(math.Copysign(0, -1))
22680 v.AddArg(v0)
22681 return true
22682 }
22683
22684
22685
22686 for {
22687 x := v.Args[0]
22688 if !(config.use387) {
22689 break
22690 }
22691 v.reset(Op386FCHS)
22692 v.AddArg(x)
22693 return true
22694 }
22695 return false
22696 }
22697 func rewriteValue386_OpNeg8_0(v *Value) bool {
22698
22699
22700
22701 for {
22702 x := v.Args[0]
22703 v.reset(Op386NEGL)
22704 v.AddArg(x)
22705 return true
22706 }
22707 }
22708 func rewriteValue386_OpNeq16_0(v *Value) bool {
22709 b := v.Block
22710
22711
22712
22713 for {
22714 y := v.Args[1]
22715 x := v.Args[0]
22716 v.reset(Op386SETNE)
22717 v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
22718 v0.AddArg(x)
22719 v0.AddArg(y)
22720 v.AddArg(v0)
22721 return true
22722 }
22723 }
22724 func rewriteValue386_OpNeq32_0(v *Value) bool {
22725 b := v.Block
22726
22727
22728
22729 for {
22730 y := v.Args[1]
22731 x := v.Args[0]
22732 v.reset(Op386SETNE)
22733 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
22734 v0.AddArg(x)
22735 v0.AddArg(y)
22736 v.AddArg(v0)
22737 return true
22738 }
22739 }
22740 func rewriteValue386_OpNeq32F_0(v *Value) bool {
22741 b := v.Block
22742
22743
22744
22745 for {
22746 y := v.Args[1]
22747 x := v.Args[0]
22748 v.reset(Op386SETNEF)
22749 v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
22750 v0.AddArg(x)
22751 v0.AddArg(y)
22752 v.AddArg(v0)
22753 return true
22754 }
22755 }
22756 func rewriteValue386_OpNeq64F_0(v *Value) bool {
22757 b := v.Block
22758
22759
22760
22761 for {
22762 y := v.Args[1]
22763 x := v.Args[0]
22764 v.reset(Op386SETNEF)
22765 v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
22766 v0.AddArg(x)
22767 v0.AddArg(y)
22768 v.AddArg(v0)
22769 return true
22770 }
22771 }
22772 func rewriteValue386_OpNeq8_0(v *Value) bool {
22773 b := v.Block
22774
22775
22776
22777 for {
22778 y := v.Args[1]
22779 x := v.Args[0]
22780 v.reset(Op386SETNE)
22781 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
22782 v0.AddArg(x)
22783 v0.AddArg(y)
22784 v.AddArg(v0)
22785 return true
22786 }
22787 }
22788 func rewriteValue386_OpNeqB_0(v *Value) bool {
22789 b := v.Block
22790
22791
22792
22793 for {
22794 y := v.Args[1]
22795 x := v.Args[0]
22796 v.reset(Op386SETNE)
22797 v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
22798 v0.AddArg(x)
22799 v0.AddArg(y)
22800 v.AddArg(v0)
22801 return true
22802 }
22803 }
22804 func rewriteValue386_OpNeqPtr_0(v *Value) bool {
22805 b := v.Block
22806
22807
22808
22809 for {
22810 y := v.Args[1]
22811 x := v.Args[0]
22812 v.reset(Op386SETNE)
22813 v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
22814 v0.AddArg(x)
22815 v0.AddArg(y)
22816 v.AddArg(v0)
22817 return true
22818 }
22819 }
22820 func rewriteValue386_OpNilCheck_0(v *Value) bool {
22821
22822
22823
22824 for {
22825 mem := v.Args[1]
22826 ptr := v.Args[0]
22827 v.reset(Op386LoweredNilCheck)
22828 v.AddArg(ptr)
22829 v.AddArg(mem)
22830 return true
22831 }
22832 }
22833 func rewriteValue386_OpNot_0(v *Value) bool {
22834
22835
22836
22837 for {
22838 x := v.Args[0]
22839 v.reset(Op386XORLconst)
22840 v.AuxInt = 1
22841 v.AddArg(x)
22842 return true
22843 }
22844 }
22845 func rewriteValue386_OpOffPtr_0(v *Value) bool {
22846
22847
22848
22849 for {
22850 off := v.AuxInt
22851 ptr := v.Args[0]
22852 v.reset(Op386ADDLconst)
22853 v.AuxInt = off
22854 v.AddArg(ptr)
22855 return true
22856 }
22857 }
22858 func rewriteValue386_OpOr16_0(v *Value) bool {
22859
22860
22861
22862 for {
22863 y := v.Args[1]
22864 x := v.Args[0]
22865 v.reset(Op386ORL)
22866 v.AddArg(x)
22867 v.AddArg(y)
22868 return true
22869 }
22870 }
22871 func rewriteValue386_OpOr32_0(v *Value) bool {
22872
22873
22874
22875 for {
22876 y := v.Args[1]
22877 x := v.Args[0]
22878 v.reset(Op386ORL)
22879 v.AddArg(x)
22880 v.AddArg(y)
22881 return true
22882 }
22883 }
22884 func rewriteValue386_OpOr8_0(v *Value) bool {
22885
22886
22887
22888 for {
22889 y := v.Args[1]
22890 x := v.Args[0]
22891 v.reset(Op386ORL)
22892 v.AddArg(x)
22893 v.AddArg(y)
22894 return true
22895 }
22896 }
22897 func rewriteValue386_OpOrB_0(v *Value) bool {
22898
22899
22900
22901 for {
22902 y := v.Args[1]
22903 x := v.Args[0]
22904 v.reset(Op386ORL)
22905 v.AddArg(x)
22906 v.AddArg(y)
22907 return true
22908 }
22909 }
22910 func rewriteValue386_OpPanicBounds_0(v *Value) bool {
22911
22912
22913
22914 for {
22915 kind := v.AuxInt
22916 mem := v.Args[2]
22917 x := v.Args[0]
22918 y := v.Args[1]
22919 if !(boundsABI(kind) == 0) {
22920 break
22921 }
22922 v.reset(Op386LoweredPanicBoundsA)
22923 v.AuxInt = kind
22924 v.AddArg(x)
22925 v.AddArg(y)
22926 v.AddArg(mem)
22927 return true
22928 }
22929
22930
22931
22932 for {
22933 kind := v.AuxInt
22934 mem := v.Args[2]
22935 x := v.Args[0]
22936 y := v.Args[1]
22937 if !(boundsABI(kind) == 1) {
22938 break
22939 }
22940 v.reset(Op386LoweredPanicBoundsB)
22941 v.AuxInt = kind
22942 v.AddArg(x)
22943 v.AddArg(y)
22944 v.AddArg(mem)
22945 return true
22946 }
22947
22948
22949
22950 for {
22951 kind := v.AuxInt
22952 mem := v.Args[2]
22953 x := v.Args[0]
22954 y := v.Args[1]
22955 if !(boundsABI(kind) == 2) {
22956 break
22957 }
22958 v.reset(Op386LoweredPanicBoundsC)
22959 v.AuxInt = kind
22960 v.AddArg(x)
22961 v.AddArg(y)
22962 v.AddArg(mem)
22963 return true
22964 }
22965 return false
22966 }
22967 func rewriteValue386_OpPanicExtend_0(v *Value) bool {
22968
22969
22970
22971 for {
22972 kind := v.AuxInt
22973 mem := v.Args[3]
22974 hi := v.Args[0]
22975 lo := v.Args[1]
22976 y := v.Args[2]
22977 if !(boundsABI(kind) == 0) {
22978 break
22979 }
22980 v.reset(Op386LoweredPanicExtendA)
22981 v.AuxInt = kind
22982 v.AddArg(hi)
22983 v.AddArg(lo)
22984 v.AddArg(y)
22985 v.AddArg(mem)
22986 return true
22987 }
22988
22989
22990
22991 for {
22992 kind := v.AuxInt
22993 mem := v.Args[3]
22994 hi := v.Args[0]
22995 lo := v.Args[1]
22996 y := v.Args[2]
22997 if !(boundsABI(kind) == 1) {
22998 break
22999 }
23000 v.reset(Op386LoweredPanicExtendB)
23001 v.AuxInt = kind
23002 v.AddArg(hi)
23003 v.AddArg(lo)
23004 v.AddArg(y)
23005 v.AddArg(mem)
23006 return true
23007 }
23008
23009
23010
23011 for {
23012 kind := v.AuxInt
23013 mem := v.Args[3]
23014 hi := v.Args[0]
23015 lo := v.Args[1]
23016 y := v.Args[2]
23017 if !(boundsABI(kind) == 2) {
23018 break
23019 }
23020 v.reset(Op386LoweredPanicExtendC)
23021 v.AuxInt = kind
23022 v.AddArg(hi)
23023 v.AddArg(lo)
23024 v.AddArg(y)
23025 v.AddArg(mem)
23026 return true
23027 }
23028 return false
23029 }
23030 func rewriteValue386_OpRotateLeft16_0(v *Value) bool {
23031
23032
23033
23034 for {
23035 _ = v.Args[1]
23036 x := v.Args[0]
23037 v_1 := v.Args[1]
23038 if v_1.Op != Op386MOVLconst {
23039 break
23040 }
23041 c := v_1.AuxInt
23042 v.reset(Op386ROLWconst)
23043 v.AuxInt = c & 15
23044 v.AddArg(x)
23045 return true
23046 }
23047 return false
23048 }
23049 func rewriteValue386_OpRotateLeft32_0(v *Value) bool {
23050
23051
23052
23053 for {
23054 _ = v.Args[1]
23055 x := v.Args[0]
23056 v_1 := v.Args[1]
23057 if v_1.Op != Op386MOVLconst {
23058 break
23059 }
23060 c := v_1.AuxInt
23061 v.reset(Op386ROLLconst)
23062 v.AuxInt = c & 31
23063 v.AddArg(x)
23064 return true
23065 }
23066 return false
23067 }
23068 func rewriteValue386_OpRotateLeft8_0(v *Value) bool {
23069
23070
23071
23072 for {
23073 _ = v.Args[1]
23074 x := v.Args[0]
23075 v_1 := v.Args[1]
23076 if v_1.Op != Op386MOVLconst {
23077 break
23078 }
23079 c := v_1.AuxInt
23080 v.reset(Op386ROLBconst)
23081 v.AuxInt = c & 7
23082 v.AddArg(x)
23083 return true
23084 }
23085 return false
23086 }
23087 func rewriteValue386_OpRound32F_0(v *Value) bool {
23088
23089
23090
23091 for {
23092 x := v.Args[0]
23093 v.reset(OpCopy)
23094 v.Type = x.Type
23095 v.AddArg(x)
23096 return true
23097 }
23098 }
23099 func rewriteValue386_OpRound64F_0(v *Value) bool {
23100
23101
23102
23103 for {
23104 x := v.Args[0]
23105 v.reset(OpCopy)
23106 v.Type = x.Type
23107 v.AddArg(x)
23108 return true
23109 }
23110 }
23111 func rewriteValue386_OpRsh16Ux16_0(v *Value) bool {
23112 b := v.Block
23113
23114
23115
23116 for {
23117 t := v.Type
23118 y := v.Args[1]
23119 x := v.Args[0]
23120 v.reset(Op386ANDL)
23121 v0 := b.NewValue0(v.Pos, Op386SHRW, t)
23122 v0.AddArg(x)
23123 v0.AddArg(y)
23124 v.AddArg(v0)
23125 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
23126 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
23127 v2.AuxInt = 16
23128 v2.AddArg(y)
23129 v1.AddArg(v2)
23130 v.AddArg(v1)
23131 return true
23132 }
23133 }
23134 func rewriteValue386_OpRsh16Ux32_0(v *Value) bool {
23135 b := v.Block
23136
23137
23138
23139 for {
23140 t := v.Type
23141 y := v.Args[1]
23142 x := v.Args[0]
23143 v.reset(Op386ANDL)
23144 v0 := b.NewValue0(v.Pos, Op386SHRW, t)
23145 v0.AddArg(x)
23146 v0.AddArg(y)
23147 v.AddArg(v0)
23148 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
23149 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
23150 v2.AuxInt = 16
23151 v2.AddArg(y)
23152 v1.AddArg(v2)
23153 v.AddArg(v1)
23154 return true
23155 }
23156 }
23157 func rewriteValue386_OpRsh16Ux64_0(v *Value) bool {
23158
23159
23160
23161 for {
23162 _ = v.Args[1]
23163 x := v.Args[0]
23164 v_1 := v.Args[1]
23165 if v_1.Op != OpConst64 {
23166 break
23167 }
23168 c := v_1.AuxInt
23169 if !(uint64(c) < 16) {
23170 break
23171 }
23172 v.reset(Op386SHRWconst)
23173 v.AuxInt = c
23174 v.AddArg(x)
23175 return true
23176 }
23177
23178
23179
23180 for {
23181 _ = v.Args[1]
23182 v_1 := v.Args[1]
23183 if v_1.Op != OpConst64 {
23184 break
23185 }
23186 c := v_1.AuxInt
23187 if !(uint64(c) >= 16) {
23188 break
23189 }
23190 v.reset(OpConst16)
23191 v.AuxInt = 0
23192 return true
23193 }
23194 return false
23195 }
23196 func rewriteValue386_OpRsh16Ux8_0(v *Value) bool {
23197 b := v.Block
23198
23199
23200
23201 for {
23202 t := v.Type
23203 y := v.Args[1]
23204 x := v.Args[0]
23205 v.reset(Op386ANDL)
23206 v0 := b.NewValue0(v.Pos, Op386SHRW, t)
23207 v0.AddArg(x)
23208 v0.AddArg(y)
23209 v.AddArg(v0)
23210 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
23211 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
23212 v2.AuxInt = 16
23213 v2.AddArg(y)
23214 v1.AddArg(v2)
23215 v.AddArg(v1)
23216 return true
23217 }
23218 }
23219 func rewriteValue386_OpRsh16x16_0(v *Value) bool {
23220 b := v.Block
23221
23222
23223
23224 for {
23225 t := v.Type
23226 y := v.Args[1]
23227 x := v.Args[0]
23228 v.reset(Op386SARW)
23229 v.Type = t
23230 v.AddArg(x)
23231 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
23232 v0.AddArg(y)
23233 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
23234 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
23235 v3 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
23236 v3.AuxInt = 16
23237 v3.AddArg(y)
23238 v2.AddArg(v3)
23239 v1.AddArg(v2)
23240 v0.AddArg(v1)
23241 v.AddArg(v0)
23242 return true
23243 }
23244 }
23245 func rewriteValue386_OpRsh16x32_0(v *Value) bool {
23246 b := v.Block
23247
23248
23249
23250 for {
23251 t := v.Type
23252 y := v.Args[1]
23253 x := v.Args[0]
23254 v.reset(Op386SARW)
23255 v.Type = t
23256 v.AddArg(x)
23257 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
23258 v0.AddArg(y)
23259 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
23260 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
23261 v3 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
23262 v3.AuxInt = 16
23263 v3.AddArg(y)
23264 v2.AddArg(v3)
23265 v1.AddArg(v2)
23266 v0.AddArg(v1)
23267 v.AddArg(v0)
23268 return true
23269 }
23270 }
23271 func rewriteValue386_OpRsh16x64_0(v *Value) bool {
23272
23273
23274
23275 for {
23276 _ = v.Args[1]
23277 x := v.Args[0]
23278 v_1 := v.Args[1]
23279 if v_1.Op != OpConst64 {
23280 break
23281 }
23282 c := v_1.AuxInt
23283 if !(uint64(c) < 16) {
23284 break
23285 }
23286 v.reset(Op386SARWconst)
23287 v.AuxInt = c
23288 v.AddArg(x)
23289 return true
23290 }
23291
23292
23293
23294 for {
23295 _ = v.Args[1]
23296 x := v.Args[0]
23297 v_1 := v.Args[1]
23298 if v_1.Op != OpConst64 {
23299 break
23300 }
23301 c := v_1.AuxInt
23302 if !(uint64(c) >= 16) {
23303 break
23304 }
23305 v.reset(Op386SARWconst)
23306 v.AuxInt = 15
23307 v.AddArg(x)
23308 return true
23309 }
23310 return false
23311 }
23312 func rewriteValue386_OpRsh16x8_0(v *Value) bool {
23313 b := v.Block
23314
23315
23316
23317 for {
23318 t := v.Type
23319 y := v.Args[1]
23320 x := v.Args[0]
23321 v.reset(Op386SARW)
23322 v.Type = t
23323 v.AddArg(x)
23324 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
23325 v0.AddArg(y)
23326 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
23327 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
23328 v3 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
23329 v3.AuxInt = 16
23330 v3.AddArg(y)
23331 v2.AddArg(v3)
23332 v1.AddArg(v2)
23333 v0.AddArg(v1)
23334 v.AddArg(v0)
23335 return true
23336 }
23337 }
23338 func rewriteValue386_OpRsh32Ux16_0(v *Value) bool {
23339 b := v.Block
23340
23341
23342
23343 for {
23344 t := v.Type
23345 y := v.Args[1]
23346 x := v.Args[0]
23347 v.reset(Op386ANDL)
23348 v0 := b.NewValue0(v.Pos, Op386SHRL, t)
23349 v0.AddArg(x)
23350 v0.AddArg(y)
23351 v.AddArg(v0)
23352 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
23353 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
23354 v2.AuxInt = 32
23355 v2.AddArg(y)
23356 v1.AddArg(v2)
23357 v.AddArg(v1)
23358 return true
23359 }
23360 }
23361 func rewriteValue386_OpRsh32Ux32_0(v *Value) bool {
23362 b := v.Block
23363
23364
23365
23366 for {
23367 t := v.Type
23368 y := v.Args[1]
23369 x := v.Args[0]
23370 v.reset(Op386ANDL)
23371 v0 := b.NewValue0(v.Pos, Op386SHRL, t)
23372 v0.AddArg(x)
23373 v0.AddArg(y)
23374 v.AddArg(v0)
23375 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
23376 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
23377 v2.AuxInt = 32
23378 v2.AddArg(y)
23379 v1.AddArg(v2)
23380 v.AddArg(v1)
23381 return true
23382 }
23383 }
23384 func rewriteValue386_OpRsh32Ux64_0(v *Value) bool {
23385
23386
23387
23388 for {
23389 _ = v.Args[1]
23390 x := v.Args[0]
23391 v_1 := v.Args[1]
23392 if v_1.Op != OpConst64 {
23393 break
23394 }
23395 c := v_1.AuxInt
23396 if !(uint64(c) < 32) {
23397 break
23398 }
23399 v.reset(Op386SHRLconst)
23400 v.AuxInt = c
23401 v.AddArg(x)
23402 return true
23403 }
23404
23405
23406
23407 for {
23408 _ = v.Args[1]
23409 v_1 := v.Args[1]
23410 if v_1.Op != OpConst64 {
23411 break
23412 }
23413 c := v_1.AuxInt
23414 if !(uint64(c) >= 32) {
23415 break
23416 }
23417 v.reset(OpConst32)
23418 v.AuxInt = 0
23419 return true
23420 }
23421 return false
23422 }
23423 func rewriteValue386_OpRsh32Ux8_0(v *Value) bool {
23424 b := v.Block
23425
23426
23427
23428 for {
23429 t := v.Type
23430 y := v.Args[1]
23431 x := v.Args[0]
23432 v.reset(Op386ANDL)
23433 v0 := b.NewValue0(v.Pos, Op386SHRL, t)
23434 v0.AddArg(x)
23435 v0.AddArg(y)
23436 v.AddArg(v0)
23437 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
23438 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
23439 v2.AuxInt = 32
23440 v2.AddArg(y)
23441 v1.AddArg(v2)
23442 v.AddArg(v1)
23443 return true
23444 }
23445 }
23446 func rewriteValue386_OpRsh32x16_0(v *Value) bool {
23447 b := v.Block
23448
23449
23450
23451 for {
23452 t := v.Type
23453 y := v.Args[1]
23454 x := v.Args[0]
23455 v.reset(Op386SARL)
23456 v.Type = t
23457 v.AddArg(x)
23458 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
23459 v0.AddArg(y)
23460 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
23461 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
23462 v3 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
23463 v3.AuxInt = 32
23464 v3.AddArg(y)
23465 v2.AddArg(v3)
23466 v1.AddArg(v2)
23467 v0.AddArg(v1)
23468 v.AddArg(v0)
23469 return true
23470 }
23471 }
23472 func rewriteValue386_OpRsh32x32_0(v *Value) bool {
23473 b := v.Block
23474
23475
23476
23477 for {
23478 t := v.Type
23479 y := v.Args[1]
23480 x := v.Args[0]
23481 v.reset(Op386SARL)
23482 v.Type = t
23483 v.AddArg(x)
23484 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
23485 v0.AddArg(y)
23486 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
23487 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
23488 v3 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
23489 v3.AuxInt = 32
23490 v3.AddArg(y)
23491 v2.AddArg(v3)
23492 v1.AddArg(v2)
23493 v0.AddArg(v1)
23494 v.AddArg(v0)
23495 return true
23496 }
23497 }
23498 func rewriteValue386_OpRsh32x64_0(v *Value) bool {
23499
23500
23501
23502 for {
23503 _ = v.Args[1]
23504 x := v.Args[0]
23505 v_1 := v.Args[1]
23506 if v_1.Op != OpConst64 {
23507 break
23508 }
23509 c := v_1.AuxInt
23510 if !(uint64(c) < 32) {
23511 break
23512 }
23513 v.reset(Op386SARLconst)
23514 v.AuxInt = c
23515 v.AddArg(x)
23516 return true
23517 }
23518
23519
23520
23521 for {
23522 _ = v.Args[1]
23523 x := v.Args[0]
23524 v_1 := v.Args[1]
23525 if v_1.Op != OpConst64 {
23526 break
23527 }
23528 c := v_1.AuxInt
23529 if !(uint64(c) >= 32) {
23530 break
23531 }
23532 v.reset(Op386SARLconst)
23533 v.AuxInt = 31
23534 v.AddArg(x)
23535 return true
23536 }
23537 return false
23538 }
23539 func rewriteValue386_OpRsh32x8_0(v *Value) bool {
23540 b := v.Block
23541
23542
23543
23544 for {
23545 t := v.Type
23546 y := v.Args[1]
23547 x := v.Args[0]
23548 v.reset(Op386SARL)
23549 v.Type = t
23550 v.AddArg(x)
23551 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
23552 v0.AddArg(y)
23553 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
23554 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
23555 v3 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
23556 v3.AuxInt = 32
23557 v3.AddArg(y)
23558 v2.AddArg(v3)
23559 v1.AddArg(v2)
23560 v0.AddArg(v1)
23561 v.AddArg(v0)
23562 return true
23563 }
23564 }
23565 func rewriteValue386_OpRsh8Ux16_0(v *Value) bool {
23566 b := v.Block
23567
23568
23569
23570 for {
23571 t := v.Type
23572 y := v.Args[1]
23573 x := v.Args[0]
23574 v.reset(Op386ANDL)
23575 v0 := b.NewValue0(v.Pos, Op386SHRB, t)
23576 v0.AddArg(x)
23577 v0.AddArg(y)
23578 v.AddArg(v0)
23579 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
23580 v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
23581 v2.AuxInt = 8
23582 v2.AddArg(y)
23583 v1.AddArg(v2)
23584 v.AddArg(v1)
23585 return true
23586 }
23587 }
23588 func rewriteValue386_OpRsh8Ux32_0(v *Value) bool {
23589 b := v.Block
23590
23591
23592
23593 for {
23594 t := v.Type
23595 y := v.Args[1]
23596 x := v.Args[0]
23597 v.reset(Op386ANDL)
23598 v0 := b.NewValue0(v.Pos, Op386SHRB, t)
23599 v0.AddArg(x)
23600 v0.AddArg(y)
23601 v.AddArg(v0)
23602 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
23603 v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
23604 v2.AuxInt = 8
23605 v2.AddArg(y)
23606 v1.AddArg(v2)
23607 v.AddArg(v1)
23608 return true
23609 }
23610 }
23611 func rewriteValue386_OpRsh8Ux64_0(v *Value) bool {
23612
23613
23614
23615 for {
23616 _ = v.Args[1]
23617 x := v.Args[0]
23618 v_1 := v.Args[1]
23619 if v_1.Op != OpConst64 {
23620 break
23621 }
23622 c := v_1.AuxInt
23623 if !(uint64(c) < 8) {
23624 break
23625 }
23626 v.reset(Op386SHRBconst)
23627 v.AuxInt = c
23628 v.AddArg(x)
23629 return true
23630 }
23631
23632
23633
23634 for {
23635 _ = v.Args[1]
23636 v_1 := v.Args[1]
23637 if v_1.Op != OpConst64 {
23638 break
23639 }
23640 c := v_1.AuxInt
23641 if !(uint64(c) >= 8) {
23642 break
23643 }
23644 v.reset(OpConst8)
23645 v.AuxInt = 0
23646 return true
23647 }
23648 return false
23649 }
23650 func rewriteValue386_OpRsh8Ux8_0(v *Value) bool {
23651 b := v.Block
23652
23653
23654
23655 for {
23656 t := v.Type
23657 y := v.Args[1]
23658 x := v.Args[0]
23659 v.reset(Op386ANDL)
23660 v0 := b.NewValue0(v.Pos, Op386SHRB, t)
23661 v0.AddArg(x)
23662 v0.AddArg(y)
23663 v.AddArg(v0)
23664 v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
23665 v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
23666 v2.AuxInt = 8
23667 v2.AddArg(y)
23668 v1.AddArg(v2)
23669 v.AddArg(v1)
23670 return true
23671 }
23672 }
23673 func rewriteValue386_OpRsh8x16_0(v *Value) bool {
23674 b := v.Block
23675
23676
23677
23678 for {
23679 t := v.Type
23680 y := v.Args[1]
23681 x := v.Args[0]
23682 v.reset(Op386SARB)
23683 v.Type = t
23684 v.AddArg(x)
23685 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
23686 v0.AddArg(y)
23687 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
23688 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
23689 v3 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
23690 v3.AuxInt = 8
23691 v3.AddArg(y)
23692 v2.AddArg(v3)
23693 v1.AddArg(v2)
23694 v0.AddArg(v1)
23695 v.AddArg(v0)
23696 return true
23697 }
23698 }
23699 func rewriteValue386_OpRsh8x32_0(v *Value) bool {
23700 b := v.Block
23701
23702
23703
23704 for {
23705 t := v.Type
23706 y := v.Args[1]
23707 x := v.Args[0]
23708 v.reset(Op386SARB)
23709 v.Type = t
23710 v.AddArg(x)
23711 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
23712 v0.AddArg(y)
23713 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
23714 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
23715 v3 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
23716 v3.AuxInt = 8
23717 v3.AddArg(y)
23718 v2.AddArg(v3)
23719 v1.AddArg(v2)
23720 v0.AddArg(v1)
23721 v.AddArg(v0)
23722 return true
23723 }
23724 }
23725 func rewriteValue386_OpRsh8x64_0(v *Value) bool {
23726
23727
23728
23729 for {
23730 _ = v.Args[1]
23731 x := v.Args[0]
23732 v_1 := v.Args[1]
23733 if v_1.Op != OpConst64 {
23734 break
23735 }
23736 c := v_1.AuxInt
23737 if !(uint64(c) < 8) {
23738 break
23739 }
23740 v.reset(Op386SARBconst)
23741 v.AuxInt = c
23742 v.AddArg(x)
23743 return true
23744 }
23745
23746
23747
23748 for {
23749 _ = v.Args[1]
23750 x := v.Args[0]
23751 v_1 := v.Args[1]
23752 if v_1.Op != OpConst64 {
23753 break
23754 }
23755 c := v_1.AuxInt
23756 if !(uint64(c) >= 8) {
23757 break
23758 }
23759 v.reset(Op386SARBconst)
23760 v.AuxInt = 7
23761 v.AddArg(x)
23762 return true
23763 }
23764 return false
23765 }
23766 func rewriteValue386_OpRsh8x8_0(v *Value) bool {
23767 b := v.Block
23768
23769
23770
23771 for {
23772 t := v.Type
23773 y := v.Args[1]
23774 x := v.Args[0]
23775 v.reset(Op386SARB)
23776 v.Type = t
23777 v.AddArg(x)
23778 v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
23779 v0.AddArg(y)
23780 v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
23781 v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
23782 v3 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
23783 v3.AuxInt = 8
23784 v3.AddArg(y)
23785 v2.AddArg(v3)
23786 v1.AddArg(v2)
23787 v0.AddArg(v1)
23788 v.AddArg(v0)
23789 return true
23790 }
23791 }
23792 func rewriteValue386_OpSelect0_0(v *Value) bool {
23793 b := v.Block
23794 typ := &b.Func.Config.Types
23795
23796
23797
23798 for {
23799 v_0 := v.Args[0]
23800 if v_0.Op != OpMul32uover {
23801 break
23802 }
23803 y := v_0.Args[1]
23804 x := v_0.Args[0]
23805 v.reset(OpSelect0)
23806 v.Type = typ.UInt32
23807 v0 := b.NewValue0(v.Pos, Op386MULLU, types.NewTuple(typ.UInt32, types.TypeFlags))
23808 v0.AddArg(x)
23809 v0.AddArg(y)
23810 v.AddArg(v0)
23811 return true
23812 }
23813 return false
23814 }
23815 func rewriteValue386_OpSelect1_0(v *Value) bool {
23816 b := v.Block
23817 typ := &b.Func.Config.Types
23818
23819
23820
23821 for {
23822 v_0 := v.Args[0]
23823 if v_0.Op != OpMul32uover {
23824 break
23825 }
23826 y := v_0.Args[1]
23827 x := v_0.Args[0]
23828 v.reset(Op386SETO)
23829 v0 := b.NewValue0(v.Pos, OpSelect1, types.TypeFlags)
23830 v1 := b.NewValue0(v.Pos, Op386MULLU, types.NewTuple(typ.UInt32, types.TypeFlags))
23831 v1.AddArg(x)
23832 v1.AddArg(y)
23833 v0.AddArg(v1)
23834 v.AddArg(v0)
23835 return true
23836 }
23837 return false
23838 }
23839 func rewriteValue386_OpSignExt16to32_0(v *Value) bool {
23840
23841
23842
23843 for {
23844 x := v.Args[0]
23845 v.reset(Op386MOVWLSX)
23846 v.AddArg(x)
23847 return true
23848 }
23849 }
23850 func rewriteValue386_OpSignExt8to16_0(v *Value) bool {
23851
23852
23853
23854 for {
23855 x := v.Args[0]
23856 v.reset(Op386MOVBLSX)
23857 v.AddArg(x)
23858 return true
23859 }
23860 }
23861 func rewriteValue386_OpSignExt8to32_0(v *Value) bool {
23862
23863
23864
23865 for {
23866 x := v.Args[0]
23867 v.reset(Op386MOVBLSX)
23868 v.AddArg(x)
23869 return true
23870 }
23871 }
23872 func rewriteValue386_OpSignmask_0(v *Value) bool {
23873
23874
23875
23876 for {
23877 x := v.Args[0]
23878 v.reset(Op386SARLconst)
23879 v.AuxInt = 31
23880 v.AddArg(x)
23881 return true
23882 }
23883 }
23884 func rewriteValue386_OpSlicemask_0(v *Value) bool {
23885 b := v.Block
23886
23887
23888
23889 for {
23890 t := v.Type
23891 x := v.Args[0]
23892 v.reset(Op386SARLconst)
23893 v.AuxInt = 31
23894 v0 := b.NewValue0(v.Pos, Op386NEGL, t)
23895 v0.AddArg(x)
23896 v.AddArg(v0)
23897 return true
23898 }
23899 }
23900 func rewriteValue386_OpSqrt_0(v *Value) bool {
23901
23902
23903
23904 for {
23905 x := v.Args[0]
23906 v.reset(Op386SQRTSD)
23907 v.AddArg(x)
23908 return true
23909 }
23910 }
23911 func rewriteValue386_OpStaticCall_0(v *Value) bool {
23912
23913
23914
23915 for {
23916 argwid := v.AuxInt
23917 target := v.Aux
23918 mem := v.Args[0]
23919 v.reset(Op386CALLstatic)
23920 v.AuxInt = argwid
23921 v.Aux = target
23922 v.AddArg(mem)
23923 return true
23924 }
23925 }
23926 func rewriteValue386_OpStore_0(v *Value) bool {
23927
23928
23929
23930 for {
23931 t := v.Aux
23932 mem := v.Args[2]
23933 ptr := v.Args[0]
23934 val := v.Args[1]
23935 if !(t.(*types.Type).Size() == 8 && is64BitFloat(val.Type)) {
23936 break
23937 }
23938 v.reset(Op386MOVSDstore)
23939 v.AddArg(ptr)
23940 v.AddArg(val)
23941 v.AddArg(mem)
23942 return true
23943 }
23944
23945
23946
23947 for {
23948 t := v.Aux
23949 mem := v.Args[2]
23950 ptr := v.Args[0]
23951 val := v.Args[1]
23952 if !(t.(*types.Type).Size() == 4 && is32BitFloat(val.Type)) {
23953 break
23954 }
23955 v.reset(Op386MOVSSstore)
23956 v.AddArg(ptr)
23957 v.AddArg(val)
23958 v.AddArg(mem)
23959 return true
23960 }
23961
23962
23963
23964 for {
23965 t := v.Aux
23966 mem := v.Args[2]
23967 ptr := v.Args[0]
23968 val := v.Args[1]
23969 if !(t.(*types.Type).Size() == 4) {
23970 break
23971 }
23972 v.reset(Op386MOVLstore)
23973 v.AddArg(ptr)
23974 v.AddArg(val)
23975 v.AddArg(mem)
23976 return true
23977 }
23978
23979
23980
23981 for {
23982 t := v.Aux
23983 mem := v.Args[2]
23984 ptr := v.Args[0]
23985 val := v.Args[1]
23986 if !(t.(*types.Type).Size() == 2) {
23987 break
23988 }
23989 v.reset(Op386MOVWstore)
23990 v.AddArg(ptr)
23991 v.AddArg(val)
23992 v.AddArg(mem)
23993 return true
23994 }
23995
23996
23997
23998 for {
23999 t := v.Aux
24000 mem := v.Args[2]
24001 ptr := v.Args[0]
24002 val := v.Args[1]
24003 if !(t.(*types.Type).Size() == 1) {
24004 break
24005 }
24006 v.reset(Op386MOVBstore)
24007 v.AddArg(ptr)
24008 v.AddArg(val)
24009 v.AddArg(mem)
24010 return true
24011 }
24012 return false
24013 }
24014 func rewriteValue386_OpSub16_0(v *Value) bool {
24015
24016
24017
24018 for {
24019 y := v.Args[1]
24020 x := v.Args[0]
24021 v.reset(Op386SUBL)
24022 v.AddArg(x)
24023 v.AddArg(y)
24024 return true
24025 }
24026 }
24027 func rewriteValue386_OpSub32_0(v *Value) bool {
24028
24029
24030
24031 for {
24032 y := v.Args[1]
24033 x := v.Args[0]
24034 v.reset(Op386SUBL)
24035 v.AddArg(x)
24036 v.AddArg(y)
24037 return true
24038 }
24039 }
24040 func rewriteValue386_OpSub32F_0(v *Value) bool {
24041
24042
24043
24044 for {
24045 y := v.Args[1]
24046 x := v.Args[0]
24047 v.reset(Op386SUBSS)
24048 v.AddArg(x)
24049 v.AddArg(y)
24050 return true
24051 }
24052 }
24053 func rewriteValue386_OpSub32carry_0(v *Value) bool {
24054
24055
24056
24057 for {
24058 y := v.Args[1]
24059 x := v.Args[0]
24060 v.reset(Op386SUBLcarry)
24061 v.AddArg(x)
24062 v.AddArg(y)
24063 return true
24064 }
24065 }
24066 func rewriteValue386_OpSub32withcarry_0(v *Value) bool {
24067
24068
24069
24070 for {
24071 c := v.Args[2]
24072 x := v.Args[0]
24073 y := v.Args[1]
24074 v.reset(Op386SBBL)
24075 v.AddArg(x)
24076 v.AddArg(y)
24077 v.AddArg(c)
24078 return true
24079 }
24080 }
24081 func rewriteValue386_OpSub64F_0(v *Value) bool {
24082
24083
24084
24085 for {
24086 y := v.Args[1]
24087 x := v.Args[0]
24088 v.reset(Op386SUBSD)
24089 v.AddArg(x)
24090 v.AddArg(y)
24091 return true
24092 }
24093 }
24094 func rewriteValue386_OpSub8_0(v *Value) bool {
24095
24096
24097
24098 for {
24099 y := v.Args[1]
24100 x := v.Args[0]
24101 v.reset(Op386SUBL)
24102 v.AddArg(x)
24103 v.AddArg(y)
24104 return true
24105 }
24106 }
24107 func rewriteValue386_OpSubPtr_0(v *Value) bool {
24108
24109
24110
24111 for {
24112 y := v.Args[1]
24113 x := v.Args[0]
24114 v.reset(Op386SUBL)
24115 v.AddArg(x)
24116 v.AddArg(y)
24117 return true
24118 }
24119 }
24120 func rewriteValue386_OpTrunc16to8_0(v *Value) bool {
24121
24122
24123
24124 for {
24125 x := v.Args[0]
24126 v.reset(OpCopy)
24127 v.Type = x.Type
24128 v.AddArg(x)
24129 return true
24130 }
24131 }
24132 func rewriteValue386_OpTrunc32to16_0(v *Value) bool {
24133
24134
24135
24136 for {
24137 x := v.Args[0]
24138 v.reset(OpCopy)
24139 v.Type = x.Type
24140 v.AddArg(x)
24141 return true
24142 }
24143 }
24144 func rewriteValue386_OpTrunc32to8_0(v *Value) bool {
24145
24146
24147
24148 for {
24149 x := v.Args[0]
24150 v.reset(OpCopy)
24151 v.Type = x.Type
24152 v.AddArg(x)
24153 return true
24154 }
24155 }
24156 func rewriteValue386_OpWB_0(v *Value) bool {
24157
24158
24159
24160 for {
24161 fn := v.Aux
24162 mem := v.Args[2]
24163 destptr := v.Args[0]
24164 srcptr := v.Args[1]
24165 v.reset(Op386LoweredWB)
24166 v.Aux = fn
24167 v.AddArg(destptr)
24168 v.AddArg(srcptr)
24169 v.AddArg(mem)
24170 return true
24171 }
24172 }
24173 func rewriteValue386_OpXor16_0(v *Value) bool {
24174
24175
24176
24177 for {
24178 y := v.Args[1]
24179 x := v.Args[0]
24180 v.reset(Op386XORL)
24181 v.AddArg(x)
24182 v.AddArg(y)
24183 return true
24184 }
24185 }
24186 func rewriteValue386_OpXor32_0(v *Value) bool {
24187
24188
24189
24190 for {
24191 y := v.Args[1]
24192 x := v.Args[0]
24193 v.reset(Op386XORL)
24194 v.AddArg(x)
24195 v.AddArg(y)
24196 return true
24197 }
24198 }
24199 func rewriteValue386_OpXor8_0(v *Value) bool {
24200
24201
24202
24203 for {
24204 y := v.Args[1]
24205 x := v.Args[0]
24206 v.reset(Op386XORL)
24207 v.AddArg(x)
24208 v.AddArg(y)
24209 return true
24210 }
24211 }
24212 func rewriteValue386_OpZero_0(v *Value) bool {
24213 b := v.Block
24214 typ := &b.Func.Config.Types
24215
24216
24217
24218 for {
24219 if v.AuxInt != 0 {
24220 break
24221 }
24222 mem := v.Args[1]
24223 v.reset(OpCopy)
24224 v.Type = mem.Type
24225 v.AddArg(mem)
24226 return true
24227 }
24228
24229
24230
24231 for {
24232 if v.AuxInt != 1 {
24233 break
24234 }
24235 mem := v.Args[1]
24236 destptr := v.Args[0]
24237 v.reset(Op386MOVBstoreconst)
24238 v.AuxInt = 0
24239 v.AddArg(destptr)
24240 v.AddArg(mem)
24241 return true
24242 }
24243
24244
24245
24246 for {
24247 if v.AuxInt != 2 {
24248 break
24249 }
24250 mem := v.Args[1]
24251 destptr := v.Args[0]
24252 v.reset(Op386MOVWstoreconst)
24253 v.AuxInt = 0
24254 v.AddArg(destptr)
24255 v.AddArg(mem)
24256 return true
24257 }
24258
24259
24260
24261 for {
24262 if v.AuxInt != 4 {
24263 break
24264 }
24265 mem := v.Args[1]
24266 destptr := v.Args[0]
24267 v.reset(Op386MOVLstoreconst)
24268 v.AuxInt = 0
24269 v.AddArg(destptr)
24270 v.AddArg(mem)
24271 return true
24272 }
24273
24274
24275
24276 for {
24277 if v.AuxInt != 3 {
24278 break
24279 }
24280 mem := v.Args[1]
24281 destptr := v.Args[0]
24282 v.reset(Op386MOVBstoreconst)
24283 v.AuxInt = makeValAndOff(0, 2)
24284 v.AddArg(destptr)
24285 v0 := b.NewValue0(v.Pos, Op386MOVWstoreconst, types.TypeMem)
24286 v0.AuxInt = 0
24287 v0.AddArg(destptr)
24288 v0.AddArg(mem)
24289 v.AddArg(v0)
24290 return true
24291 }
24292
24293
24294
24295 for {
24296 if v.AuxInt != 5 {
24297 break
24298 }
24299 mem := v.Args[1]
24300 destptr := v.Args[0]
24301 v.reset(Op386MOVBstoreconst)
24302 v.AuxInt = makeValAndOff(0, 4)
24303 v.AddArg(destptr)
24304 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
24305 v0.AuxInt = 0
24306 v0.AddArg(destptr)
24307 v0.AddArg(mem)
24308 v.AddArg(v0)
24309 return true
24310 }
24311
24312
24313
24314 for {
24315 if v.AuxInt != 6 {
24316 break
24317 }
24318 mem := v.Args[1]
24319 destptr := v.Args[0]
24320 v.reset(Op386MOVWstoreconst)
24321 v.AuxInt = makeValAndOff(0, 4)
24322 v.AddArg(destptr)
24323 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
24324 v0.AuxInt = 0
24325 v0.AddArg(destptr)
24326 v0.AddArg(mem)
24327 v.AddArg(v0)
24328 return true
24329 }
24330
24331
24332
24333 for {
24334 if v.AuxInt != 7 {
24335 break
24336 }
24337 mem := v.Args[1]
24338 destptr := v.Args[0]
24339 v.reset(Op386MOVLstoreconst)
24340 v.AuxInt = makeValAndOff(0, 3)
24341 v.AddArg(destptr)
24342 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
24343 v0.AuxInt = 0
24344 v0.AddArg(destptr)
24345 v0.AddArg(mem)
24346 v.AddArg(v0)
24347 return true
24348 }
24349
24350
24351
24352 for {
24353 s := v.AuxInt
24354 mem := v.Args[1]
24355 destptr := v.Args[0]
24356 if !(s%4 != 0 && s > 4) {
24357 break
24358 }
24359 v.reset(OpZero)
24360 v.AuxInt = s - s%4
24361 v0 := b.NewValue0(v.Pos, Op386ADDLconst, typ.UInt32)
24362 v0.AuxInt = s % 4
24363 v0.AddArg(destptr)
24364 v.AddArg(v0)
24365 v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
24366 v1.AuxInt = 0
24367 v1.AddArg(destptr)
24368 v1.AddArg(mem)
24369 v.AddArg(v1)
24370 return true
24371 }
24372
24373
24374
24375 for {
24376 if v.AuxInt != 8 {
24377 break
24378 }
24379 mem := v.Args[1]
24380 destptr := v.Args[0]
24381 v.reset(Op386MOVLstoreconst)
24382 v.AuxInt = makeValAndOff(0, 4)
24383 v.AddArg(destptr)
24384 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
24385 v0.AuxInt = 0
24386 v0.AddArg(destptr)
24387 v0.AddArg(mem)
24388 v.AddArg(v0)
24389 return true
24390 }
24391 return false
24392 }
24393 func rewriteValue386_OpZero_10(v *Value) bool {
24394 b := v.Block
24395 config := b.Func.Config
24396 typ := &b.Func.Config.Types
24397
24398
24399
24400 for {
24401 if v.AuxInt != 12 {
24402 break
24403 }
24404 mem := v.Args[1]
24405 destptr := v.Args[0]
24406 v.reset(Op386MOVLstoreconst)
24407 v.AuxInt = makeValAndOff(0, 8)
24408 v.AddArg(destptr)
24409 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
24410 v0.AuxInt = makeValAndOff(0, 4)
24411 v0.AddArg(destptr)
24412 v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
24413 v1.AuxInt = 0
24414 v1.AddArg(destptr)
24415 v1.AddArg(mem)
24416 v0.AddArg(v1)
24417 v.AddArg(v0)
24418 return true
24419 }
24420
24421
24422
24423 for {
24424 if v.AuxInt != 16 {
24425 break
24426 }
24427 mem := v.Args[1]
24428 destptr := v.Args[0]
24429 v.reset(Op386MOVLstoreconst)
24430 v.AuxInt = makeValAndOff(0, 12)
24431 v.AddArg(destptr)
24432 v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
24433 v0.AuxInt = makeValAndOff(0, 8)
24434 v0.AddArg(destptr)
24435 v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
24436 v1.AuxInt = makeValAndOff(0, 4)
24437 v1.AddArg(destptr)
24438 v2 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
24439 v2.AuxInt = 0
24440 v2.AddArg(destptr)
24441 v2.AddArg(mem)
24442 v1.AddArg(v2)
24443 v0.AddArg(v1)
24444 v.AddArg(v0)
24445 return true
24446 }
24447
24448
24449
24450 for {
24451 s := v.AuxInt
24452 mem := v.Args[1]
24453 destptr := v.Args[0]
24454 if !(s > 16 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice) {
24455 break
24456 }
24457 v.reset(Op386DUFFZERO)
24458 v.AuxInt = 1 * (128 - s/4)
24459 v.AddArg(destptr)
24460 v0 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32)
24461 v0.AuxInt = 0
24462 v.AddArg(v0)
24463 v.AddArg(mem)
24464 return true
24465 }
24466
24467
24468
24469 for {
24470 s := v.AuxInt
24471 mem := v.Args[1]
24472 destptr := v.Args[0]
24473 if !((s > 4*128 || (config.noDuffDevice && s > 16)) && s%4 == 0) {
24474 break
24475 }
24476 v.reset(Op386REPSTOSL)
24477 v.AddArg(destptr)
24478 v0 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32)
24479 v0.AuxInt = s / 4
24480 v.AddArg(v0)
24481 v1 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32)
24482 v1.AuxInt = 0
24483 v.AddArg(v1)
24484 v.AddArg(mem)
24485 return true
24486 }
24487 return false
24488 }
24489 func rewriteValue386_OpZeroExt16to32_0(v *Value) bool {
24490
24491
24492
24493 for {
24494 x := v.Args[0]
24495 v.reset(Op386MOVWLZX)
24496 v.AddArg(x)
24497 return true
24498 }
24499 }
24500 func rewriteValue386_OpZeroExt8to16_0(v *Value) bool {
24501
24502
24503
24504 for {
24505 x := v.Args[0]
24506 v.reset(Op386MOVBLZX)
24507 v.AddArg(x)
24508 return true
24509 }
24510 }
24511 func rewriteValue386_OpZeroExt8to32_0(v *Value) bool {
24512
24513
24514
24515 for {
24516 x := v.Args[0]
24517 v.reset(Op386MOVBLZX)
24518 v.AddArg(x)
24519 return true
24520 }
24521 }
24522 func rewriteValue386_OpZeromask_0(v *Value) bool {
24523 b := v.Block
24524
24525
24526
24527 for {
24528 t := v.Type
24529 x := v.Args[0]
24530 v.reset(Op386XORLconst)
24531 v.AuxInt = -1
24532 v0 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
24533 v1 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
24534 v1.AuxInt = 1
24535 v1.AddArg(x)
24536 v0.AddArg(v1)
24537 v.AddArg(v0)
24538 return true
24539 }
24540 }
24541 func rewriteBlock386(b *Block) bool {
24542 config := b.Func.Config
24543 typ := &config.Types
24544 _ = typ
24545 v := b.Control
24546 _ = v
24547 switch b.Kind {
24548 case Block386EQ:
24549
24550
24551
24552 for v.Op == Op386InvertFlags {
24553 cmp := v.Args[0]
24554 b.Kind = Block386EQ
24555 b.SetControl(cmp)
24556 b.Aux = nil
24557 return true
24558 }
24559
24560
24561
24562 for v.Op == Op386FlagEQ {
24563 b.Kind = BlockFirst
24564 b.SetControl(nil)
24565 b.Aux = nil
24566 return true
24567 }
24568
24569
24570
24571 for v.Op == Op386FlagLT_ULT {
24572 b.Kind = BlockFirst
24573 b.SetControl(nil)
24574 b.Aux = nil
24575 b.swapSuccessors()
24576 return true
24577 }
24578
24579
24580
24581 for v.Op == Op386FlagLT_UGT {
24582 b.Kind = BlockFirst
24583 b.SetControl(nil)
24584 b.Aux = nil
24585 b.swapSuccessors()
24586 return true
24587 }
24588
24589
24590
24591 for v.Op == Op386FlagGT_ULT {
24592 b.Kind = BlockFirst
24593 b.SetControl(nil)
24594 b.Aux = nil
24595 b.swapSuccessors()
24596 return true
24597 }
24598
24599
24600
24601 for v.Op == Op386FlagGT_UGT {
24602 b.Kind = BlockFirst
24603 b.SetControl(nil)
24604 b.Aux = nil
24605 b.swapSuccessors()
24606 return true
24607 }
24608 case Block386GE:
24609
24610
24611
24612 for v.Op == Op386InvertFlags {
24613 cmp := v.Args[0]
24614 b.Kind = Block386LE
24615 b.SetControl(cmp)
24616 b.Aux = nil
24617 return true
24618 }
24619
24620
24621
24622 for v.Op == Op386FlagEQ {
24623 b.Kind = BlockFirst
24624 b.SetControl(nil)
24625 b.Aux = nil
24626 return true
24627 }
24628
24629
24630
24631 for v.Op == Op386FlagLT_ULT {
24632 b.Kind = BlockFirst
24633 b.SetControl(nil)
24634 b.Aux = nil
24635 b.swapSuccessors()
24636 return true
24637 }
24638
24639
24640
24641 for v.Op == Op386FlagLT_UGT {
24642 b.Kind = BlockFirst
24643 b.SetControl(nil)
24644 b.Aux = nil
24645 b.swapSuccessors()
24646 return true
24647 }
24648
24649
24650
24651 for v.Op == Op386FlagGT_ULT {
24652 b.Kind = BlockFirst
24653 b.SetControl(nil)
24654 b.Aux = nil
24655 return true
24656 }
24657
24658
24659
24660 for v.Op == Op386FlagGT_UGT {
24661 b.Kind = BlockFirst
24662 b.SetControl(nil)
24663 b.Aux = nil
24664 return true
24665 }
24666 case Block386GT:
24667
24668
24669
24670 for v.Op == Op386InvertFlags {
24671 cmp := v.Args[0]
24672 b.Kind = Block386LT
24673 b.SetControl(cmp)
24674 b.Aux = nil
24675 return true
24676 }
24677
24678
24679
24680 for v.Op == Op386FlagEQ {
24681 b.Kind = BlockFirst
24682 b.SetControl(nil)
24683 b.Aux = nil
24684 b.swapSuccessors()
24685 return true
24686 }
24687
24688
24689
24690 for v.Op == Op386FlagLT_ULT {
24691 b.Kind = BlockFirst
24692 b.SetControl(nil)
24693 b.Aux = nil
24694 b.swapSuccessors()
24695 return true
24696 }
24697
24698
24699
24700 for v.Op == Op386FlagLT_UGT {
24701 b.Kind = BlockFirst
24702 b.SetControl(nil)
24703 b.Aux = nil
24704 b.swapSuccessors()
24705 return true
24706 }
24707
24708
24709
24710 for v.Op == Op386FlagGT_ULT {
24711 b.Kind = BlockFirst
24712 b.SetControl(nil)
24713 b.Aux = nil
24714 return true
24715 }
24716
24717
24718
24719 for v.Op == Op386FlagGT_UGT {
24720 b.Kind = BlockFirst
24721 b.SetControl(nil)
24722 b.Aux = nil
24723 return true
24724 }
24725 case BlockIf:
24726
24727
24728
24729 for v.Op == Op386SETL {
24730 cmp := v.Args[0]
24731 b.Kind = Block386LT
24732 b.SetControl(cmp)
24733 b.Aux = nil
24734 return true
24735 }
24736
24737
24738
24739 for v.Op == Op386SETLE {
24740 cmp := v.Args[0]
24741 b.Kind = Block386LE
24742 b.SetControl(cmp)
24743 b.Aux = nil
24744 return true
24745 }
24746
24747
24748
24749 for v.Op == Op386SETG {
24750 cmp := v.Args[0]
24751 b.Kind = Block386GT
24752 b.SetControl(cmp)
24753 b.Aux = nil
24754 return true
24755 }
24756
24757
24758
24759 for v.Op == Op386SETGE {
24760 cmp := v.Args[0]
24761 b.Kind = Block386GE
24762 b.SetControl(cmp)
24763 b.Aux = nil
24764 return true
24765 }
24766
24767
24768
24769 for v.Op == Op386SETEQ {
24770 cmp := v.Args[0]
24771 b.Kind = Block386EQ
24772 b.SetControl(cmp)
24773 b.Aux = nil
24774 return true
24775 }
24776
24777
24778
24779 for v.Op == Op386SETNE {
24780 cmp := v.Args[0]
24781 b.Kind = Block386NE
24782 b.SetControl(cmp)
24783 b.Aux = nil
24784 return true
24785 }
24786
24787
24788
24789 for v.Op == Op386SETB {
24790 cmp := v.Args[0]
24791 b.Kind = Block386ULT
24792 b.SetControl(cmp)
24793 b.Aux = nil
24794 return true
24795 }
24796
24797
24798
24799 for v.Op == Op386SETBE {
24800 cmp := v.Args[0]
24801 b.Kind = Block386ULE
24802 b.SetControl(cmp)
24803 b.Aux = nil
24804 return true
24805 }
24806
24807
24808
24809 for v.Op == Op386SETA {
24810 cmp := v.Args[0]
24811 b.Kind = Block386UGT
24812 b.SetControl(cmp)
24813 b.Aux = nil
24814 return true
24815 }
24816
24817
24818
24819 for v.Op == Op386SETAE {
24820 cmp := v.Args[0]
24821 b.Kind = Block386UGE
24822 b.SetControl(cmp)
24823 b.Aux = nil
24824 return true
24825 }
24826
24827
24828
24829 for v.Op == Op386SETO {
24830 cmp := v.Args[0]
24831 b.Kind = Block386OS
24832 b.SetControl(cmp)
24833 b.Aux = nil
24834 return true
24835 }
24836
24837
24838
24839 for v.Op == Op386SETGF {
24840 cmp := v.Args[0]
24841 b.Kind = Block386UGT
24842 b.SetControl(cmp)
24843 b.Aux = nil
24844 return true
24845 }
24846
24847
24848
24849 for v.Op == Op386SETGEF {
24850 cmp := v.Args[0]
24851 b.Kind = Block386UGE
24852 b.SetControl(cmp)
24853 b.Aux = nil
24854 return true
24855 }
24856
24857
24858
24859 for v.Op == Op386SETEQF {
24860 cmp := v.Args[0]
24861 b.Kind = Block386EQF
24862 b.SetControl(cmp)
24863 b.Aux = nil
24864 return true
24865 }
24866
24867
24868
24869 for v.Op == Op386SETNEF {
24870 cmp := v.Args[0]
24871 b.Kind = Block386NEF
24872 b.SetControl(cmp)
24873 b.Aux = nil
24874 return true
24875 }
24876
24877
24878
24879 for {
24880 cond := b.Control
24881 b.Kind = Block386NE
24882 v0 := b.NewValue0(v.Pos, Op386TESTB, types.TypeFlags)
24883 v0.AddArg(cond)
24884 v0.AddArg(cond)
24885 b.SetControl(v0)
24886 b.Aux = nil
24887 return true
24888 }
24889 case Block386LE:
24890
24891
24892
24893 for v.Op == Op386InvertFlags {
24894 cmp := v.Args[0]
24895 b.Kind = Block386GE
24896 b.SetControl(cmp)
24897 b.Aux = nil
24898 return true
24899 }
24900
24901
24902
24903 for v.Op == Op386FlagEQ {
24904 b.Kind = BlockFirst
24905 b.SetControl(nil)
24906 b.Aux = nil
24907 return true
24908 }
24909
24910
24911
24912 for v.Op == Op386FlagLT_ULT {
24913 b.Kind = BlockFirst
24914 b.SetControl(nil)
24915 b.Aux = nil
24916 return true
24917 }
24918
24919
24920
24921 for v.Op == Op386FlagLT_UGT {
24922 b.Kind = BlockFirst
24923 b.SetControl(nil)
24924 b.Aux = nil
24925 return true
24926 }
24927
24928
24929
24930 for v.Op == Op386FlagGT_ULT {
24931 b.Kind = BlockFirst
24932 b.SetControl(nil)
24933 b.Aux = nil
24934 b.swapSuccessors()
24935 return true
24936 }
24937
24938
24939
24940 for v.Op == Op386FlagGT_UGT {
24941 b.Kind = BlockFirst
24942 b.SetControl(nil)
24943 b.Aux = nil
24944 b.swapSuccessors()
24945 return true
24946 }
24947 case Block386LT:
24948
24949
24950
24951 for v.Op == Op386InvertFlags {
24952 cmp := v.Args[0]
24953 b.Kind = Block386GT
24954 b.SetControl(cmp)
24955 b.Aux = nil
24956 return true
24957 }
24958
24959
24960
24961 for v.Op == Op386FlagEQ {
24962 b.Kind = BlockFirst
24963 b.SetControl(nil)
24964 b.Aux = nil
24965 b.swapSuccessors()
24966 return true
24967 }
24968
24969
24970
24971 for v.Op == Op386FlagLT_ULT {
24972 b.Kind = BlockFirst
24973 b.SetControl(nil)
24974 b.Aux = nil
24975 return true
24976 }
24977
24978
24979
24980 for v.Op == Op386FlagLT_UGT {
24981 b.Kind = BlockFirst
24982 b.SetControl(nil)
24983 b.Aux = nil
24984 return true
24985 }
24986
24987
24988
24989 for v.Op == Op386FlagGT_ULT {
24990 b.Kind = BlockFirst
24991 b.SetControl(nil)
24992 b.Aux = nil
24993 b.swapSuccessors()
24994 return true
24995 }
24996
24997
24998
24999 for v.Op == Op386FlagGT_UGT {
25000 b.Kind = BlockFirst
25001 b.SetControl(nil)
25002 b.Aux = nil
25003 b.swapSuccessors()
25004 return true
25005 }
25006 case Block386NE:
25007
25008
25009
25010 for v.Op == Op386TESTB {
25011 _ = v.Args[1]
25012 v_0 := v.Args[0]
25013 if v_0.Op != Op386SETL {
25014 break
25015 }
25016 cmp := v_0.Args[0]
25017 v_1 := v.Args[1]
25018 if v_1.Op != Op386SETL {
25019 break
25020 }
25021 if cmp != v_1.Args[0] {
25022 break
25023 }
25024 b.Kind = Block386LT
25025 b.SetControl(cmp)
25026 b.Aux = nil
25027 return true
25028 }
25029
25030
25031
25032 for v.Op == Op386TESTB {
25033 _ = v.Args[1]
25034 v_0 := v.Args[0]
25035 if v_0.Op != Op386SETL {
25036 break
25037 }
25038 cmp := v_0.Args[0]
25039 v_1 := v.Args[1]
25040 if v_1.Op != Op386SETL {
25041 break
25042 }
25043 if cmp != v_1.Args[0] {
25044 break
25045 }
25046 b.Kind = Block386LT
25047 b.SetControl(cmp)
25048 b.Aux = nil
25049 return true
25050 }
25051
25052
25053
25054 for v.Op == Op386TESTB {
25055 _ = v.Args[1]
25056 v_0 := v.Args[0]
25057 if v_0.Op != Op386SETLE {
25058 break
25059 }
25060 cmp := v_0.Args[0]
25061 v_1 := v.Args[1]
25062 if v_1.Op != Op386SETLE {
25063 break
25064 }
25065 if cmp != v_1.Args[0] {
25066 break
25067 }
25068 b.Kind = Block386LE
25069 b.SetControl(cmp)
25070 b.Aux = nil
25071 return true
25072 }
25073
25074
25075
25076 for v.Op == Op386TESTB {
25077 _ = v.Args[1]
25078 v_0 := v.Args[0]
25079 if v_0.Op != Op386SETLE {
25080 break
25081 }
25082 cmp := v_0.Args[0]
25083 v_1 := v.Args[1]
25084 if v_1.Op != Op386SETLE {
25085 break
25086 }
25087 if cmp != v_1.Args[0] {
25088 break
25089 }
25090 b.Kind = Block386LE
25091 b.SetControl(cmp)
25092 b.Aux = nil
25093 return true
25094 }
25095
25096
25097
25098 for v.Op == Op386TESTB {
25099 _ = v.Args[1]
25100 v_0 := v.Args[0]
25101 if v_0.Op != Op386SETG {
25102 break
25103 }
25104 cmp := v_0.Args[0]
25105 v_1 := v.Args[1]
25106 if v_1.Op != Op386SETG {
25107 break
25108 }
25109 if cmp != v_1.Args[0] {
25110 break
25111 }
25112 b.Kind = Block386GT
25113 b.SetControl(cmp)
25114 b.Aux = nil
25115 return true
25116 }
25117
25118
25119
25120 for v.Op == Op386TESTB {
25121 _ = v.Args[1]
25122 v_0 := v.Args[0]
25123 if v_0.Op != Op386SETG {
25124 break
25125 }
25126 cmp := v_0.Args[0]
25127 v_1 := v.Args[1]
25128 if v_1.Op != Op386SETG {
25129 break
25130 }
25131 if cmp != v_1.Args[0] {
25132 break
25133 }
25134 b.Kind = Block386GT
25135 b.SetControl(cmp)
25136 b.Aux = nil
25137 return true
25138 }
25139
25140
25141
25142 for v.Op == Op386TESTB {
25143 _ = v.Args[1]
25144 v_0 := v.Args[0]
25145 if v_0.Op != Op386SETGE {
25146 break
25147 }
25148 cmp := v_0.Args[0]
25149 v_1 := v.Args[1]
25150 if v_1.Op != Op386SETGE {
25151 break
25152 }
25153 if cmp != v_1.Args[0] {
25154 break
25155 }
25156 b.Kind = Block386GE
25157 b.SetControl(cmp)
25158 b.Aux = nil
25159 return true
25160 }
25161
25162
25163
25164 for v.Op == Op386TESTB {
25165 _ = v.Args[1]
25166 v_0 := v.Args[0]
25167 if v_0.Op != Op386SETGE {
25168 break
25169 }
25170 cmp := v_0.Args[0]
25171 v_1 := v.Args[1]
25172 if v_1.Op != Op386SETGE {
25173 break
25174 }
25175 if cmp != v_1.Args[0] {
25176 break
25177 }
25178 b.Kind = Block386GE
25179 b.SetControl(cmp)
25180 b.Aux = nil
25181 return true
25182 }
25183
25184
25185
25186 for v.Op == Op386TESTB {
25187 _ = v.Args[1]
25188 v_0 := v.Args[0]
25189 if v_0.Op != Op386SETEQ {
25190 break
25191 }
25192 cmp := v_0.Args[0]
25193 v_1 := v.Args[1]
25194 if v_1.Op != Op386SETEQ {
25195 break
25196 }
25197 if cmp != v_1.Args[0] {
25198 break
25199 }
25200 b.Kind = Block386EQ
25201 b.SetControl(cmp)
25202 b.Aux = nil
25203 return true
25204 }
25205
25206
25207
25208 for v.Op == Op386TESTB {
25209 _ = v.Args[1]
25210 v_0 := v.Args[0]
25211 if v_0.Op != Op386SETEQ {
25212 break
25213 }
25214 cmp := v_0.Args[0]
25215 v_1 := v.Args[1]
25216 if v_1.Op != Op386SETEQ {
25217 break
25218 }
25219 if cmp != v_1.Args[0] {
25220 break
25221 }
25222 b.Kind = Block386EQ
25223 b.SetControl(cmp)
25224 b.Aux = nil
25225 return true
25226 }
25227
25228
25229
25230 for v.Op == Op386TESTB {
25231 _ = v.Args[1]
25232 v_0 := v.Args[0]
25233 if v_0.Op != Op386SETNE {
25234 break
25235 }
25236 cmp := v_0.Args[0]
25237 v_1 := v.Args[1]
25238 if v_1.Op != Op386SETNE {
25239 break
25240 }
25241 if cmp != v_1.Args[0] {
25242 break
25243 }
25244 b.Kind = Block386NE
25245 b.SetControl(cmp)
25246 b.Aux = nil
25247 return true
25248 }
25249
25250
25251
25252 for v.Op == Op386TESTB {
25253 _ = v.Args[1]
25254 v_0 := v.Args[0]
25255 if v_0.Op != Op386SETNE {
25256 break
25257 }
25258 cmp := v_0.Args[0]
25259 v_1 := v.Args[1]
25260 if v_1.Op != Op386SETNE {
25261 break
25262 }
25263 if cmp != v_1.Args[0] {
25264 break
25265 }
25266 b.Kind = Block386NE
25267 b.SetControl(cmp)
25268 b.Aux = nil
25269 return true
25270 }
25271
25272
25273
25274 for v.Op == Op386TESTB {
25275 _ = v.Args[1]
25276 v_0 := v.Args[0]
25277 if v_0.Op != Op386SETB {
25278 break
25279 }
25280 cmp := v_0.Args[0]
25281 v_1 := v.Args[1]
25282 if v_1.Op != Op386SETB {
25283 break
25284 }
25285 if cmp != v_1.Args[0] {
25286 break
25287 }
25288 b.Kind = Block386ULT
25289 b.SetControl(cmp)
25290 b.Aux = nil
25291 return true
25292 }
25293
25294
25295
25296 for v.Op == Op386TESTB {
25297 _ = v.Args[1]
25298 v_0 := v.Args[0]
25299 if v_0.Op != Op386SETB {
25300 break
25301 }
25302 cmp := v_0.Args[0]
25303 v_1 := v.Args[1]
25304 if v_1.Op != Op386SETB {
25305 break
25306 }
25307 if cmp != v_1.Args[0] {
25308 break
25309 }
25310 b.Kind = Block386ULT
25311 b.SetControl(cmp)
25312 b.Aux = nil
25313 return true
25314 }
25315
25316
25317
25318 for v.Op == Op386TESTB {
25319 _ = v.Args[1]
25320 v_0 := v.Args[0]
25321 if v_0.Op != Op386SETBE {
25322 break
25323 }
25324 cmp := v_0.Args[0]
25325 v_1 := v.Args[1]
25326 if v_1.Op != Op386SETBE {
25327 break
25328 }
25329 if cmp != v_1.Args[0] {
25330 break
25331 }
25332 b.Kind = Block386ULE
25333 b.SetControl(cmp)
25334 b.Aux = nil
25335 return true
25336 }
25337
25338
25339
25340 for v.Op == Op386TESTB {
25341 _ = v.Args[1]
25342 v_0 := v.Args[0]
25343 if v_0.Op != Op386SETBE {
25344 break
25345 }
25346 cmp := v_0.Args[0]
25347 v_1 := v.Args[1]
25348 if v_1.Op != Op386SETBE {
25349 break
25350 }
25351 if cmp != v_1.Args[0] {
25352 break
25353 }
25354 b.Kind = Block386ULE
25355 b.SetControl(cmp)
25356 b.Aux = nil
25357 return true
25358 }
25359
25360
25361
25362 for v.Op == Op386TESTB {
25363 _ = v.Args[1]
25364 v_0 := v.Args[0]
25365 if v_0.Op != Op386SETA {
25366 break
25367 }
25368 cmp := v_0.Args[0]
25369 v_1 := v.Args[1]
25370 if v_1.Op != Op386SETA {
25371 break
25372 }
25373 if cmp != v_1.Args[0] {
25374 break
25375 }
25376 b.Kind = Block386UGT
25377 b.SetControl(cmp)
25378 b.Aux = nil
25379 return true
25380 }
25381
25382
25383
25384 for v.Op == Op386TESTB {
25385 _ = v.Args[1]
25386 v_0 := v.Args[0]
25387 if v_0.Op != Op386SETA {
25388 break
25389 }
25390 cmp := v_0.Args[0]
25391 v_1 := v.Args[1]
25392 if v_1.Op != Op386SETA {
25393 break
25394 }
25395 if cmp != v_1.Args[0] {
25396 break
25397 }
25398 b.Kind = Block386UGT
25399 b.SetControl(cmp)
25400 b.Aux = nil
25401 return true
25402 }
25403
25404
25405
25406 for v.Op == Op386TESTB {
25407 _ = v.Args[1]
25408 v_0 := v.Args[0]
25409 if v_0.Op != Op386SETAE {
25410 break
25411 }
25412 cmp := v_0.Args[0]
25413 v_1 := v.Args[1]
25414 if v_1.Op != Op386SETAE {
25415 break
25416 }
25417 if cmp != v_1.Args[0] {
25418 break
25419 }
25420 b.Kind = Block386UGE
25421 b.SetControl(cmp)
25422 b.Aux = nil
25423 return true
25424 }
25425
25426
25427
25428 for v.Op == Op386TESTB {
25429 _ = v.Args[1]
25430 v_0 := v.Args[0]
25431 if v_0.Op != Op386SETAE {
25432 break
25433 }
25434 cmp := v_0.Args[0]
25435 v_1 := v.Args[1]
25436 if v_1.Op != Op386SETAE {
25437 break
25438 }
25439 if cmp != v_1.Args[0] {
25440 break
25441 }
25442 b.Kind = Block386UGE
25443 b.SetControl(cmp)
25444 b.Aux = nil
25445 return true
25446 }
25447
25448
25449
25450 for v.Op == Op386TESTB {
25451 _ = v.Args[1]
25452 v_0 := v.Args[0]
25453 if v_0.Op != Op386SETO {
25454 break
25455 }
25456 cmp := v_0.Args[0]
25457 v_1 := v.Args[1]
25458 if v_1.Op != Op386SETO {
25459 break
25460 }
25461 if cmp != v_1.Args[0] {
25462 break
25463 }
25464 b.Kind = Block386OS
25465 b.SetControl(cmp)
25466 b.Aux = nil
25467 return true
25468 }
25469
25470
25471
25472 for v.Op == Op386TESTB {
25473 _ = v.Args[1]
25474 v_0 := v.Args[0]
25475 if v_0.Op != Op386SETO {
25476 break
25477 }
25478 cmp := v_0.Args[0]
25479 v_1 := v.Args[1]
25480 if v_1.Op != Op386SETO {
25481 break
25482 }
25483 if cmp != v_1.Args[0] {
25484 break
25485 }
25486 b.Kind = Block386OS
25487 b.SetControl(cmp)
25488 b.Aux = nil
25489 return true
25490 }
25491
25492
25493
25494 for v.Op == Op386TESTB {
25495 _ = v.Args[1]
25496 v_0 := v.Args[0]
25497 if v_0.Op != Op386SETGF {
25498 break
25499 }
25500 cmp := v_0.Args[0]
25501 v_1 := v.Args[1]
25502 if v_1.Op != Op386SETGF {
25503 break
25504 }
25505 if cmp != v_1.Args[0] {
25506 break
25507 }
25508 b.Kind = Block386UGT
25509 b.SetControl(cmp)
25510 b.Aux = nil
25511 return true
25512 }
25513
25514
25515
25516 for v.Op == Op386TESTB {
25517 _ = v.Args[1]
25518 v_0 := v.Args[0]
25519 if v_0.Op != Op386SETGF {
25520 break
25521 }
25522 cmp := v_0.Args[0]
25523 v_1 := v.Args[1]
25524 if v_1.Op != Op386SETGF {
25525 break
25526 }
25527 if cmp != v_1.Args[0] {
25528 break
25529 }
25530 b.Kind = Block386UGT
25531 b.SetControl(cmp)
25532 b.Aux = nil
25533 return true
25534 }
25535
25536
25537
25538 for v.Op == Op386TESTB {
25539 _ = v.Args[1]
25540 v_0 := v.Args[0]
25541 if v_0.Op != Op386SETGEF {
25542 break
25543 }
25544 cmp := v_0.Args[0]
25545 v_1 := v.Args[1]
25546 if v_1.Op != Op386SETGEF {
25547 break
25548 }
25549 if cmp != v_1.Args[0] {
25550 break
25551 }
25552 b.Kind = Block386UGE
25553 b.SetControl(cmp)
25554 b.Aux = nil
25555 return true
25556 }
25557
25558
25559
25560 for v.Op == Op386TESTB {
25561 _ = v.Args[1]
25562 v_0 := v.Args[0]
25563 if v_0.Op != Op386SETGEF {
25564 break
25565 }
25566 cmp := v_0.Args[0]
25567 v_1 := v.Args[1]
25568 if v_1.Op != Op386SETGEF {
25569 break
25570 }
25571 if cmp != v_1.Args[0] {
25572 break
25573 }
25574 b.Kind = Block386UGE
25575 b.SetControl(cmp)
25576 b.Aux = nil
25577 return true
25578 }
25579
25580
25581
25582 for v.Op == Op386TESTB {
25583 _ = v.Args[1]
25584 v_0 := v.Args[0]
25585 if v_0.Op != Op386SETEQF {
25586 break
25587 }
25588 cmp := v_0.Args[0]
25589 v_1 := v.Args[1]
25590 if v_1.Op != Op386SETEQF {
25591 break
25592 }
25593 if cmp != v_1.Args[0] {
25594 break
25595 }
25596 b.Kind = Block386EQF
25597 b.SetControl(cmp)
25598 b.Aux = nil
25599 return true
25600 }
25601
25602
25603
25604 for v.Op == Op386TESTB {
25605 _ = v.Args[1]
25606 v_0 := v.Args[0]
25607 if v_0.Op != Op386SETEQF {
25608 break
25609 }
25610 cmp := v_0.Args[0]
25611 v_1 := v.Args[1]
25612 if v_1.Op != Op386SETEQF {
25613 break
25614 }
25615 if cmp != v_1.Args[0] {
25616 break
25617 }
25618 b.Kind = Block386EQF
25619 b.SetControl(cmp)
25620 b.Aux = nil
25621 return true
25622 }
25623
25624
25625
25626 for v.Op == Op386TESTB {
25627 _ = v.Args[1]
25628 v_0 := v.Args[0]
25629 if v_0.Op != Op386SETNEF {
25630 break
25631 }
25632 cmp := v_0.Args[0]
25633 v_1 := v.Args[1]
25634 if v_1.Op != Op386SETNEF {
25635 break
25636 }
25637 if cmp != v_1.Args[0] {
25638 break
25639 }
25640 b.Kind = Block386NEF
25641 b.SetControl(cmp)
25642 b.Aux = nil
25643 return true
25644 }
25645
25646
25647
25648 for v.Op == Op386TESTB {
25649 _ = v.Args[1]
25650 v_0 := v.Args[0]
25651 if v_0.Op != Op386SETNEF {
25652 break
25653 }
25654 cmp := v_0.Args[0]
25655 v_1 := v.Args[1]
25656 if v_1.Op != Op386SETNEF {
25657 break
25658 }
25659 if cmp != v_1.Args[0] {
25660 break
25661 }
25662 b.Kind = Block386NEF
25663 b.SetControl(cmp)
25664 b.Aux = nil
25665 return true
25666 }
25667
25668
25669
25670 for v.Op == Op386InvertFlags {
25671 cmp := v.Args[0]
25672 b.Kind = Block386NE
25673 b.SetControl(cmp)
25674 b.Aux = nil
25675 return true
25676 }
25677
25678
25679
25680 for v.Op == Op386FlagEQ {
25681 b.Kind = BlockFirst
25682 b.SetControl(nil)
25683 b.Aux = nil
25684 b.swapSuccessors()
25685 return true
25686 }
25687
25688
25689
25690 for v.Op == Op386FlagLT_ULT {
25691 b.Kind = BlockFirst
25692 b.SetControl(nil)
25693 b.Aux = nil
25694 return true
25695 }
25696
25697
25698
25699 for v.Op == Op386FlagLT_UGT {
25700 b.Kind = BlockFirst
25701 b.SetControl(nil)
25702 b.Aux = nil
25703 return true
25704 }
25705
25706
25707
25708 for v.Op == Op386FlagGT_ULT {
25709 b.Kind = BlockFirst
25710 b.SetControl(nil)
25711 b.Aux = nil
25712 return true
25713 }
25714
25715
25716
25717 for v.Op == Op386FlagGT_UGT {
25718 b.Kind = BlockFirst
25719 b.SetControl(nil)
25720 b.Aux = nil
25721 return true
25722 }
25723 case Block386UGE:
25724
25725
25726
25727 for v.Op == Op386InvertFlags {
25728 cmp := v.Args[0]
25729 b.Kind = Block386ULE
25730 b.SetControl(cmp)
25731 b.Aux = nil
25732 return true
25733 }
25734
25735
25736
25737 for v.Op == Op386FlagEQ {
25738 b.Kind = BlockFirst
25739 b.SetControl(nil)
25740 b.Aux = nil
25741 return true
25742 }
25743
25744
25745
25746 for v.Op == Op386FlagLT_ULT {
25747 b.Kind = BlockFirst
25748 b.SetControl(nil)
25749 b.Aux = nil
25750 b.swapSuccessors()
25751 return true
25752 }
25753
25754
25755
25756 for v.Op == Op386FlagLT_UGT {
25757 b.Kind = BlockFirst
25758 b.SetControl(nil)
25759 b.Aux = nil
25760 return true
25761 }
25762
25763
25764
25765 for v.Op == Op386FlagGT_ULT {
25766 b.Kind = BlockFirst
25767 b.SetControl(nil)
25768 b.Aux = nil
25769 b.swapSuccessors()
25770 return true
25771 }
25772
25773
25774
25775 for v.Op == Op386FlagGT_UGT {
25776 b.Kind = BlockFirst
25777 b.SetControl(nil)
25778 b.Aux = nil
25779 return true
25780 }
25781 case Block386UGT:
25782
25783
25784
25785 for v.Op == Op386InvertFlags {
25786 cmp := v.Args[0]
25787 b.Kind = Block386ULT
25788 b.SetControl(cmp)
25789 b.Aux = nil
25790 return true
25791 }
25792
25793
25794
25795 for v.Op == Op386FlagEQ {
25796 b.Kind = BlockFirst
25797 b.SetControl(nil)
25798 b.Aux = nil
25799 b.swapSuccessors()
25800 return true
25801 }
25802
25803
25804
25805 for v.Op == Op386FlagLT_ULT {
25806 b.Kind = BlockFirst
25807 b.SetControl(nil)
25808 b.Aux = nil
25809 b.swapSuccessors()
25810 return true
25811 }
25812
25813
25814
25815 for v.Op == Op386FlagLT_UGT {
25816 b.Kind = BlockFirst
25817 b.SetControl(nil)
25818 b.Aux = nil
25819 return true
25820 }
25821
25822
25823
25824 for v.Op == Op386FlagGT_ULT {
25825 b.Kind = BlockFirst
25826 b.SetControl(nil)
25827 b.Aux = nil
25828 b.swapSuccessors()
25829 return true
25830 }
25831
25832
25833
25834 for v.Op == Op386FlagGT_UGT {
25835 b.Kind = BlockFirst
25836 b.SetControl(nil)
25837 b.Aux = nil
25838 return true
25839 }
25840 case Block386ULE:
25841
25842
25843
25844 for v.Op == Op386InvertFlags {
25845 cmp := v.Args[0]
25846 b.Kind = Block386UGE
25847 b.SetControl(cmp)
25848 b.Aux = nil
25849 return true
25850 }
25851
25852
25853
25854 for v.Op == Op386FlagEQ {
25855 b.Kind = BlockFirst
25856 b.SetControl(nil)
25857 b.Aux = nil
25858 return true
25859 }
25860
25861
25862
25863 for v.Op == Op386FlagLT_ULT {
25864 b.Kind = BlockFirst
25865 b.SetControl(nil)
25866 b.Aux = nil
25867 return true
25868 }
25869
25870
25871
25872 for v.Op == Op386FlagLT_UGT {
25873 b.Kind = BlockFirst
25874 b.SetControl(nil)
25875 b.Aux = nil
25876 b.swapSuccessors()
25877 return true
25878 }
25879
25880
25881
25882 for v.Op == Op386FlagGT_ULT {
25883 b.Kind = BlockFirst
25884 b.SetControl(nil)
25885 b.Aux = nil
25886 return true
25887 }
25888
25889
25890
25891 for v.Op == Op386FlagGT_UGT {
25892 b.Kind = BlockFirst
25893 b.SetControl(nil)
25894 b.Aux = nil
25895 b.swapSuccessors()
25896 return true
25897 }
25898 case Block386ULT:
25899
25900
25901
25902 for v.Op == Op386InvertFlags {
25903 cmp := v.Args[0]
25904 b.Kind = Block386UGT
25905 b.SetControl(cmp)
25906 b.Aux = nil
25907 return true
25908 }
25909
25910
25911
25912 for v.Op == Op386FlagEQ {
25913 b.Kind = BlockFirst
25914 b.SetControl(nil)
25915 b.Aux = nil
25916 b.swapSuccessors()
25917 return true
25918 }
25919
25920
25921
25922 for v.Op == Op386FlagLT_ULT {
25923 b.Kind = BlockFirst
25924 b.SetControl(nil)
25925 b.Aux = nil
25926 return true
25927 }
25928
25929
25930
25931 for v.Op == Op386FlagLT_UGT {
25932 b.Kind = BlockFirst
25933 b.SetControl(nil)
25934 b.Aux = nil
25935 b.swapSuccessors()
25936 return true
25937 }
25938
25939
25940
25941 for v.Op == Op386FlagGT_ULT {
25942 b.Kind = BlockFirst
25943 b.SetControl(nil)
25944 b.Aux = nil
25945 return true
25946 }
25947
25948
25949
25950 for v.Op == Op386FlagGT_UGT {
25951 b.Kind = BlockFirst
25952 b.SetControl(nil)
25953 b.Aux = nil
25954 b.swapSuccessors()
25955 return true
25956 }
25957 }
25958 return false
25959 }
25960
View as plain text