basis/compiler/cfg/value-numbering/simplify/simplify.factor

   1 ! Copyright (C) 2008, 2009 Slava Pestov.
   2 ! See http://factorcode.org/license.txt for BSD license.
   3 USING: kernel accessors combinators classes math layouts
   4 sequences math.vectors.simd.intrinsics
   5 compiler.cfg.instructions
   6 compiler.cfg.value-numbering.graph
   7 compiler.cfg.value-numbering.expressions ;
   8 IN: compiler.cfg.value-numbering.simplify
   9
  10 ! Return value of f means we didn't simplify.
  11 GENERIC: simplify* ( expr -- vn/expr/f )
  12
  13 M: copy-expr simplify* src>> ;
  14
  15 : simplify-unbox-alien ( expr -- vn/expr/f )
  16     src>> vn>expr dup box-alien-expr? [ src>> ] [ drop f ] if ;
  17
  18 M: unbox-alien-expr simplify* simplify-unbox-alien ;
  19
  20 M: unbox-any-c-ptr-expr simplify* simplify-unbox-alien ;
  21
  22 : expr-zero? ( expr -- ? ) T{ constant-expr f 0 } = ; inline
  23
  24 : expr-one? ( expr -- ? ) T{ constant-expr f 1 } = ; inline
  25
  26 : expr-neg-one? ( expr -- ? ) T{ constant-expr f -1 } = ; inline
  27
  28 : >unary-expr< ( expr -- in ) src>> vn>expr ; inline
  29
  30 M: neg-expr simplify*
  31     >unary-expr< {
  32         { [ dup neg-expr? ] [ src>> ] }
  33         [ drop f ]
  34     } cond ;
  35
  36 M: not-expr simplify*
  37     >unary-expr< {
  38         { [ dup not-expr? ] [ src>> ] }
  39         [ drop f ]
  40     } cond ;
  41
  42 : >binary-expr< ( expr -- in1 in2 )
  43     [ src1>> vn>expr ] [ src2>> vn>expr ] bi ; inline
  44
  45 : simplify-add ( expr -- vn/expr/f )
  46     >binary-expr< {
  47         { [ over expr-zero? ] [ nip ] }
  48         { [ dup expr-zero? ] [ drop ] }
  49         [ 2drop f ]
  50     } cond ; inline
  51
  52 M: add-expr simplify* simplify-add ;
  53 M: add-imm-expr simplify* simplify-add ;
  54
  55 : simplify-sub ( expr -- vn/expr/f )
  56     >binary-expr< {
  57         { [ dup expr-zero? ] [ drop ] }
  58         [ 2drop f ]
  59     } cond ; inline
  60
  61 M: sub-expr simplify* simplify-sub ;
  62 M: sub-imm-expr simplify* simplify-sub ;
  63
  64 : simplify-mul ( expr -- vn/expr/f )
  65     >binary-expr< {
  66         { [ over expr-one? ] [ drop ] }
  67         { [ dup expr-one? ] [ drop ] }
  68         [ 2drop f ]
  69     } cond ; inline
  70
  71 M: mul-expr simplify* simplify-mul ;
  72 M: mul-imm-expr simplify* simplify-mul ;
  73
  74 : simplify-and ( expr -- vn/expr/f )
  75     >binary-expr< {
  76         { [ 2dup eq? ] [ drop ] }
  77         [ 2drop f ]
  78     } cond ; inline
  79
  80 M: and-expr simplify* simplify-and ;
  81 M: and-imm-expr simplify* simplify-and ;
  82
  83 : simplify-or ( expr -- vn/expr/f )
  84     >binary-expr< {
  85         { [ 2dup eq? ] [ drop ] }
  86         { [ over expr-zero? ] [ nip ] }
  87         { [ dup expr-zero? ] [ drop ] }
  88         [ 2drop f ]
  89     } cond ; inline
  90
  91 M: or-expr simplify* simplify-or ;
  92 M: or-imm-expr simplify* simplify-or ;
  93
  94 : simplify-xor ( expr -- vn/expr/f )
  95     >binary-expr< {
  96         { [ over expr-zero? ] [ nip ] }
  97         { [ dup expr-zero? ] [ drop ] }
  98         [ 2drop f ]
  99     } cond ; inline
 100
 101 M: xor-expr simplify* simplify-xor ;
 102 M: xor-imm-expr simplify* simplify-xor ;
 103
 104 : useless-shr? ( in1 in2 -- ? )
 105     over shl-imm-expr?
 106     [ [ src2>> ] [ expr>vn ] bi* = ] [ 2drop f ] if ; inline
 107
 108 : simplify-shr ( expr -- vn/expr/f )
 109     >binary-expr< {
 110         { [ 2dup useless-shr? ] [ drop src1>> ] }
 111         { [ dup expr-zero? ] [ drop ] }
 112         [ 2drop f ]
 113     } cond ; inline
 114
 115 M: shr-expr simplify* simplify-shr ;
 116 M: shr-imm-expr simplify* simplify-shr ;
 117
 118 : simplify-shl ( expr -- vn/expr/f )
 119     >binary-expr< {
 120         { [ dup expr-zero? ] [ drop ] }
 121         [ 2drop f ]
 122     } cond ; inline
 123
 124 M: shl-expr simplify* simplify-shl ;
 125 M: shl-imm-expr simplify* simplify-shl ;
 126
 127 M: box-displaced-alien-expr simplify*
 128     [ base>> ] [ displacement>> ] bi {
 129         { [ dup vn>expr expr-zero? ] [ drop ] }
 130         [ 2drop f ]
 131     } cond ;
 132
 133 M: scalar>vector-expr simplify*
 134     src>> vn>expr {
 135         { [ dup vector>scalar-expr? ] [ src>> ] }
 136         [ drop f ]
 137     } cond ;
 138
 139 M: shuffle-vector-imm-expr simplify*
 140     [ src>> ] [ shuffle>> ] [ rep>> rep-components iota ] tri
 141     sequence= [ drop f ] unless ;
 142
 143 M: expr simplify* drop f ;
 144
 145 : simplify ( expr -- vn )
 146     dup simplify* {
 147         { [ dup not ] [ drop expr>vn ] }
 148         { [ dup expr? ] [ expr>vn nip ] }
 149         { [ dup integer? ] [ nip ] }
 150     } cond ;
 151
 152 : number-values ( insn -- )
 153     [ >expr simplify ] [ dst>> ] bi set-vn ;