1 ! Copyright (C) 2008, 2009 Slava Pestov, Doug Coleman, Daniel Ehrenberg.
2 ! See http://factorcode.org/license.txt for BSD license.
3 USING: accessors combinators combinators.short-circuit arrays
4 fry kernel layouts math namespaces sequences cpu.architecture
5 math.bitwise math.order math.vectors.simd.intrinsics classes
6 vectors locals make alien.c-types io.binary grouping
9 compiler.cfg.comparisons
10 compiler.cfg.instructions
11 compiler.cfg.value-numbering.expressions
12 compiler.cfg.value-numbering.graph
13 compiler.cfg.value-numbering.simplify ;
14 IN: compiler.cfg.value-numbering.rewrite
16 : vreg-immediate-arithmetic? ( vreg -- ? )
20 [ value>> immediate-arithmetic? ]
23 : vreg-immediate-bitwise? ( vreg -- ? )
27 [ value>> immediate-bitwise? ]
30 ! Outputs f to mean no change
32 GENERIC: rewrite ( insn -- insn/f )
34 M: insn rewrite drop f ;
36 : ##branch-t? ( insn -- ? )
37 dup ##compare-imm-branch? [
40 [ src2>> \ f type-number eq? ]
42 ] [ drop f ] if ; inline
44 : general-compare-expr? ( insn -- ? )
48 [ compare-float-unordered-expr? ]
49 [ compare-float-ordered-expr? ]
53 : rewrite-boolean-comparison? ( insn -- ? )
55 src1>> vreg>expr general-compare-expr?
56 ] [ drop f ] if ; inline
58 : >compare-expr< ( expr -- in1 in2 cc )
59 [ src1>> vn>vreg ] [ src2>> vn>vreg ] [ cc>> ] tri ; inline
61 : >compare-imm-expr< ( expr -- in1 in2 cc )
62 [ src1>> vn>vreg ] [ src2>> vn>constant ] [ cc>> ] tri ; inline
64 : >test-vector-expr< ( expr -- src1 temp rep vcc )
72 : rewrite-boolean-comparison ( expr -- insn )
74 { [ dup compare-expr? ] [ >compare-expr< \ ##compare-branch new-insn ] }
75 { [ dup compare-imm-expr? ] [ >compare-imm-expr< \ ##compare-imm-branch new-insn ] }
76 { [ dup compare-float-unordered-expr? ] [ >compare-expr< \ ##compare-float-unordered-branch new-insn ] }
77 { [ dup compare-float-ordered-expr? ] [ >compare-expr< \ ##compare-float-ordered-branch new-insn ] }
78 { [ dup test-vector-expr? ] [ >test-vector-expr< \ ##test-vector-branch new-insn ] }
81 : tag-fixnum-expr? ( expr -- ? )
83 [ src2>> vn>constant tag-bits get = ] [ drop f ] if ;
85 : rewrite-tagged-comparison? ( insn -- ? )
86 #! Are we comparing two tagged fixnums? Then untag them.
88 [ src1>> vreg>expr tag-fixnum-expr? ]
89 [ src2>> tag-mask get bitand 0 = ]
92 : tagged>constant ( n -- n' )
93 tag-bits get neg shift ; inline
95 : (rewrite-tagged-comparison) ( insn -- src1 src2 cc )
96 [ src1>> vreg>expr src1>> vn>vreg ]
97 [ src2>> tagged>constant ]
101 GENERIC: rewrite-tagged-comparison ( insn -- insn/f )
103 M: ##compare-imm-branch rewrite-tagged-comparison
104 (rewrite-tagged-comparison) \ ##compare-imm-branch new-insn ;
106 M: ##compare-imm rewrite-tagged-comparison
107 [ dst>> ] [ (rewrite-tagged-comparison) ] bi
108 next-vreg \ ##compare-imm new-insn ;
110 : rewrite-redundant-comparison? ( insn -- ? )
112 [ src1>> vreg>expr general-compare-expr? ]
113 [ src2>> \ f type-number = ]
114 [ cc>> { cc= cc/= } member-eq? ]
117 : rewrite-redundant-comparison ( insn -- insn' )
118 [ cc>> ] [ dst>> ] [ src1>> vreg>expr ] tri {
119 { [ dup compare-expr? ] [ >compare-expr< next-vreg \ ##compare new-insn ] }
120 { [ dup compare-imm-expr? ] [ >compare-imm-expr< next-vreg \ ##compare-imm new-insn ] }
121 { [ dup compare-float-unordered-expr? ] [ >compare-expr< next-vreg \ ##compare-float-unordered new-insn ] }
122 { [ dup compare-float-ordered-expr? ] [ >compare-expr< next-vreg \ ##compare-float-ordered new-insn ] }
124 swap cc= eq? [ [ negate-cc ] change-cc ] when ;
126 ERROR: bad-comparison ;
128 : (fold-compare-imm) ( insn -- ? )
129 [ [ src1>> vreg>constant ] [ src2>> ] bi ] [ cc>> ] bi
131 [ [ <=> ] dip evaluate-cc ]
140 : fold-compare-imm? ( insn -- ? )
141 src1>> vreg>expr [ constant-expr? ] [ reference-expr? ] bi or ;
143 : fold-branch ( ? -- insn )
145 basic-block get [ nth 1vector ] change-successors drop
146 \ ##branch new-insn ;
148 : fold-compare-imm-branch ( insn -- insn/f )
149 (fold-compare-imm) fold-branch ;
151 M: ##compare-imm-branch rewrite
153 { [ dup rewrite-boolean-comparison? ] [ rewrite-boolean-comparison ] }
154 { [ dup rewrite-tagged-comparison? ] [ rewrite-tagged-comparison ] }
155 { [ dup fold-compare-imm? ] [ fold-compare-imm-branch ] }
159 : swap-compare ( src1 src2 cc swap? -- src1 src2 cc )
160 [ [ swap ] dip swap-cc ] when ; inline
162 : >compare-imm-branch ( insn swap? -- insn' )
170 [ vreg>constant ] dip
171 \ ##compare-imm-branch new-insn ; inline
173 : self-compare? ( insn -- ? )
174 [ src1>> ] [ src2>> ] bi [ vreg>vn ] bi@ = ; inline
176 : (rewrite-self-compare) ( insn -- ? )
177 cc>> { cc= cc<= cc>= } member-eq? ;
179 : rewrite-self-compare-branch ( insn -- insn' )
180 (rewrite-self-compare) fold-branch ;
182 M: ##compare-branch rewrite
184 { [ dup src1>> vreg-immediate-arithmetic? ] [ t >compare-imm-branch ] }
185 { [ dup src2>> vreg-immediate-arithmetic? ] [ f >compare-imm-branch ] }
186 { [ dup self-compare? ] [ rewrite-self-compare-branch ] }
190 : >compare-imm ( insn swap? -- insn' )
200 [ vreg>constant ] dip
201 next-vreg \ ##compare-imm new-insn ; inline
203 : >boolean-insn ( insn ? -- insn' )
206 { t [ t \ ##load-constant new-insn ] }
207 { f [ \ f type-number \ ##load-immediate new-insn ] }
210 : rewrite-self-compare ( insn -- insn' )
211 dup (rewrite-self-compare) >boolean-insn ;
215 { [ dup src1>> vreg-immediate-arithmetic? ] [ t >compare-imm ] }
216 { [ dup src2>> vreg-immediate-arithmetic? ] [ f >compare-imm ] }
217 { [ dup self-compare? ] [ rewrite-self-compare ] }
221 : fold-compare-imm ( insn -- insn' )
222 dup (fold-compare-imm) >boolean-insn ;
224 M: ##compare-imm rewrite
226 { [ dup rewrite-redundant-comparison? ] [ rewrite-redundant-comparison ] }
227 { [ dup rewrite-tagged-comparison? ] [ rewrite-tagged-comparison ] }
228 { [ dup fold-compare-imm? ] [ fold-compare-imm ] }
232 : constant-fold? ( insn -- ? )
233 src1>> vreg>expr constant-expr? ; inline
235 GENERIC: constant-fold* ( x y insn -- z )
237 M: ##add-imm constant-fold* drop + ;
238 M: ##sub-imm constant-fold* drop - ;
239 M: ##mul-imm constant-fold* drop * ;
240 M: ##and-imm constant-fold* drop bitand ;
241 M: ##or-imm constant-fold* drop bitor ;
242 M: ##xor-imm constant-fold* drop bitxor ;
243 M: ##shr-imm constant-fold* drop [ cell-bits 2^ wrap ] dip neg shift ;
244 M: ##sar-imm constant-fold* drop neg shift ;
245 M: ##shl-imm constant-fold* drop shift ;
247 : constant-fold ( insn -- insn' )
249 [ [ src1>> vreg>constant ] [ src2>> ] [ ] tri constant-fold* ] bi
250 \ ##load-immediate new-insn ; inline
252 : unary-constant-fold? ( insn -- ? )
253 src>> vreg>expr constant-expr? ; inline
255 GENERIC: unary-constant-fold* ( x insn -- y )
257 M: ##not unary-constant-fold* drop bitnot ;
258 M: ##neg unary-constant-fold* drop neg ;
260 : unary-constant-fold ( insn -- insn' )
262 [ [ src>> vreg>constant ] [ ] bi unary-constant-fold* ] bi
263 \ ##load-immediate new-insn ; inline
265 : maybe-unary-constant-fold ( insn -- insn' )
266 dup unary-constant-fold? [ unary-constant-fold ] [ drop f ] if ;
269 maybe-unary-constant-fold ;
272 maybe-unary-constant-fold ;
274 : arithmetic-op? ( op -- ? )
284 : immediate? ( value op -- ? )
285 arithmetic-op? [ immediate-arithmetic? ] [ immediate-bitwise? ] if ;
287 : reassociate ( insn op -- insn )
291 [ src1>> vreg>expr [ src1>> vn>vreg ] [ src2>> vn>constant ] bi ]
294 } cleave constant-fold*
296 2dup immediate? [ new-insn ] [ 2drop 2drop f ] if ; inline
300 { [ dup constant-fold? ] [ constant-fold ] }
301 { [ dup src1>> vreg>expr add-imm-expr? ] [ \ ##add-imm reassociate ] }
305 : sub-imm>add-imm ( insn -- insn' )
306 [ dst>> ] [ src1>> ] [ src2>> neg ] tri dup immediate-arithmetic?
307 [ \ ##add-imm new-insn ] [ 3drop f ] if ;
311 { [ dup constant-fold? ] [ constant-fold ] }
315 : mul-to-neg? ( insn -- ? )
318 : mul-to-neg ( insn -- insn' )
319 [ dst>> ] [ src1>> ] bi \ ##neg new-insn ;
321 : mul-to-shl? ( insn -- ? )
324 : mul-to-shl ( insn -- insn' )
325 [ [ dst>> ] [ src1>> ] bi ] [ src2>> log2 ] bi \ ##shl-imm new-insn ;
329 { [ dup constant-fold? ] [ constant-fold ] }
330 { [ dup mul-to-neg? ] [ mul-to-neg ] }
331 { [ dup mul-to-shl? ] [ mul-to-shl ] }
332 { [ dup src1>> vreg>expr mul-imm-expr? ] [ \ ##mul-imm reassociate ] }
338 { [ dup constant-fold? ] [ constant-fold ] }
339 { [ dup src1>> vreg>expr and-imm-expr? ] [ \ ##and-imm reassociate ] }
345 { [ dup constant-fold? ] [ constant-fold ] }
346 { [ dup src1>> vreg>expr or-imm-expr? ] [ \ ##or-imm reassociate ] }
352 { [ dup constant-fold? ] [ constant-fold ] }
353 { [ dup src1>> vreg>expr xor-imm-expr? ] [ \ ##xor-imm reassociate ] }
359 { [ dup constant-fold? ] [ constant-fold ] }
365 { [ dup constant-fold? ] [ constant-fold ] }
371 { [ dup constant-fold? ] [ constant-fold ] }
375 : insn>imm-insn ( insn op swap? -- )
377 [ [ dst>> ] [ src1>> ] [ src2>> ] tri ] dip
378 [ swap ] when vreg>constant
379 ] dip new-insn ; inline
381 : vreg-immediate? ( vreg op -- ? )
383 [ vreg-immediate-arithmetic? ] [ vreg-immediate-bitwise? ] if ;
385 : rewrite-arithmetic ( insn op -- ? )
387 { [ over src2>> over vreg-immediate? ] [ f insn>imm-insn ] }
391 : rewrite-arithmetic-commutative ( insn op -- ? )
393 { [ over src2>> over vreg-immediate? ] [ f insn>imm-insn ] }
394 { [ over src1>> over vreg-immediate? ] [ t insn>imm-insn ] }
398 M: ##add rewrite \ ##add-imm rewrite-arithmetic-commutative ;
400 : subtraction-identity? ( insn -- ? )
401 [ src1>> ] [ src2>> ] bi [ vreg>vn ] bi@ eq? ;
403 : rewrite-subtraction-identity ( insn -- insn' )
404 dst>> 0 \ ##load-immediate new-insn ;
406 : sub-to-neg? ( ##sub -- ? )
407 src1>> vn>expr expr-zero? ;
409 : sub-to-neg ( ##sub -- insn )
410 [ dst>> ] [ src2>> ] bi \ ##neg new-insn ;
414 { [ dup sub-to-neg? ] [ sub-to-neg ] }
415 { [ dup subtraction-identity? ] [ rewrite-subtraction-identity ] }
416 [ \ ##sub-imm rewrite-arithmetic ]
419 M: ##mul rewrite \ ##mul-imm rewrite-arithmetic-commutative ;
421 M: ##and rewrite \ ##and-imm rewrite-arithmetic-commutative ;
423 M: ##or rewrite \ ##or-imm rewrite-arithmetic-commutative ;
425 M: ##xor rewrite \ ##xor-imm rewrite-arithmetic-commutative ;
427 M: ##shl rewrite \ ##shl-imm rewrite-arithmetic ;
429 M: ##shr rewrite \ ##shr-imm rewrite-arithmetic ;
431 M: ##sar rewrite \ ##sar-imm rewrite-arithmetic ;
433 ! ##box-displaced-alien f 1 2 3 <class>
434 ! ##unbox-c-ptr 4 1 <class>
436 ! ##box-displaced-alien f 1 2 3 <class>
437 ! ##unbox-c-ptr 5 3 <class>
440 :: rewrite-unbox-displaced-alien ( insn expr -- insns )
443 temp expr base>> vn>vreg expr base-class>> ##unbox-c-ptr
444 insn dst>> temp expr displacement>> vn>vreg ##add
447 M: ##unbox-any-c-ptr rewrite
448 dup src>> vreg>expr dup box-displaced-alien-expr?
449 [ rewrite-unbox-displaced-alien ] [ 2drop f ] if ;
451 ! More efficient addressing for alien intrinsics
452 : rewrite-alien-addressing ( insn -- insn' )
453 dup src>> vreg>expr dup add-imm-expr? [
454 [ src1>> vn>vreg ] [ src2>> vn>constant ] bi
455 [ >>src ] [ '[ _ + ] change-offset ] bi*
458 M: ##alien-unsigned-1 rewrite rewrite-alien-addressing ;
459 M: ##alien-unsigned-2 rewrite rewrite-alien-addressing ;
460 M: ##alien-unsigned-4 rewrite rewrite-alien-addressing ;
461 M: ##alien-signed-1 rewrite rewrite-alien-addressing ;
462 M: ##alien-signed-2 rewrite rewrite-alien-addressing ;
463 M: ##alien-signed-4 rewrite rewrite-alien-addressing ;
464 M: ##alien-float rewrite rewrite-alien-addressing ;
465 M: ##alien-double rewrite rewrite-alien-addressing ;
466 M: ##alien-vector rewrite rewrite-alien-addressing ;
467 M: ##set-alien-integer-1 rewrite rewrite-alien-addressing ;
468 M: ##set-alien-integer-2 rewrite rewrite-alien-addressing ;
469 M: ##set-alien-integer-4 rewrite rewrite-alien-addressing ;
470 M: ##set-alien-float rewrite rewrite-alien-addressing ;
471 M: ##set-alien-double rewrite rewrite-alien-addressing ;
472 M: ##set-alien-vector rewrite rewrite-alien-addressing ;
474 ! Some lame constant folding for SIMD intrinsics. Eventually this
475 ! should be redone completely.
477 : rewrite-shuffle-vector-imm ( insn expr -- insn' )
478 2dup [ rep>> ] bi@ eq? [
479 [ [ dst>> ] [ src>> vn>vreg ] bi* ]
480 [ [ shuffle>> ] bi@ nths ]
482 2tri \ ##shuffle-vector-imm new-insn
485 : (fold-shuffle-vector-imm) ( shuffle bytes -- bytes' )
486 2dup length swap length /i group nths concat ;
488 : fold-shuffle-vector-imm ( insn expr -- insn' )
489 [ [ dst>> ] [ shuffle>> ] bi ] dip value>>
490 (fold-shuffle-vector-imm) \ ##load-constant new-insn ;
492 M: ##shuffle-vector-imm rewrite
493 dup src>> vreg>expr {
494 { [ dup shuffle-vector-imm-expr? ] [ rewrite-shuffle-vector-imm ] }
495 { [ dup reference-expr? ] [ fold-shuffle-vector-imm ] }
496 { [ dup constant-expr? ] [ fold-shuffle-vector-imm ] }
500 : (fold-scalar>vector) ( insn bytes -- insn' )
501 [ [ dst>> ] [ rep>> rep-components ] bi ] dip <repetition> concat
502 \ ##load-constant new-insn ;
504 : fold-scalar>vector ( insn expr -- insn' )
506 { float-4-rep [ float>bits 4 >le (fold-scalar>vector) ] }
507 { double-2-rep [ double>bits 8 >le (fold-scalar>vector) ] }
508 [ [ untag-fixnum ] dip rep-component-type heap-size >le (fold-scalar>vector) ]
511 M: ##scalar>vector rewrite
512 dup src>> vreg>expr dup constant-expr?
513 [ fold-scalar>vector ] [ 2drop f ] if ;
515 M: ##xor-vector rewrite
516 dup [ src1>> vreg>vn ] [ src2>> vreg>vn ] bi eq?
517 [ [ dst>> ] [ rep>> ] bi \ ##zero-vector new-insn ] [ drop f ] if ;
519 : vector-not? ( expr -- ? )
524 [ [ src1>> ] [ src2>> ] bi [ vn>expr fill-vector-expr? ] either? ]
528 GENERIC: vector-not-src ( expr -- vreg )
529 M: not-vector-expr vector-not-src src>> vn>vreg ;
530 M: xor-vector-expr vector-not-src
531 dup src1>> vn>expr fill-vector-expr? [ src2>> ] [ src1>> ] if vn>vreg ;
533 M: ##and-vector rewrite
535 { [ dup src1>> vreg>expr vector-not? ] [
538 [ src1>> vreg>expr vector-not-src ]
541 } cleave \ ##andn-vector new-insn
543 { [ dup src2>> vreg>expr vector-not? ] [
546 [ src2>> vreg>expr vector-not-src ]
549 } cleave \ ##andn-vector new-insn
554 M: ##andn-vector rewrite
555 dup src1>> vreg>expr vector-not? [
558 [ src1>> vreg>expr vector-not-src ]
561 } cleave \ ##and-vector new-insn