factor/basis/compiler/cfg/instructions/instructions.factor

! Copyright (C) 2008, 2011 Slava Pestov.
! See http://factorcode.org/license.txt for BSD license.
USING: accessors compiler.cfg.instructions.syntax kernel math
namespaces ;
IN: compiler.cfg.instructions

<<
SYMBOL: insn-classes
V{ } clone insn-classes set-global
>>

: new-insn ( ... class -- insn ) f swap boa ; inline

TUPLE: insn ;

TUPLE: vreg-insn < insn ;

TUPLE: flushable-insn < vreg-insn ;

TUPLE: foldable-insn < flushable-insn ;

! Constants
FOLDABLE-INSN: load-integer##
def: dst/int-rep
literal: val ;

FOLDABLE-INSN: load-reference##
def: dst/tagged-rep
literal: obj ;

! These four are inserted by representation selection
FLUSHABLE-INSN: load-tagged##
def: dst/tagged-rep
literal: val ;

FLUSHABLE-INSN: load-float##
def: dst/float-rep
literal: val ;

FLUSHABLE-INSN: load-double##
def: dst/double-rep
literal: val ;

FLUSHABLE-INSN: load-vector##
def: dst
literal: val rep ;

! Stack operations
FLUSHABLE-INSN: peek##
def: dst/tagged-rep
literal: loc ;

VREG-INSN: replace##
use: src/tagged-rep
literal: loc ;

INSN: replace-imm##
literal: src loc ;

INSN: clear##
literal: loc ;

INSN: inc##
literal: loc ;

! Subroutine calls
INSN: call##
literal: word ;

INSN: jump##
literal: word ;

INSN: prologue## ;

INSN: epilogue## ;

INSN: return## ;

INSN: safepoint## ;

INSN: no-tco## ;

! Jump tables
VREG-INSN: dispatch##
use: src/int-rep
temp: temp/int-rep ;

! Slot access
FLUSHABLE-INSN: slot##
def: dst/tagged-rep
use: obj/tagged-rep slot/int-rep
literal: scale tag ;

FLUSHABLE-INSN: slot-imm##
def: dst/tagged-rep
use: obj/tagged-rep
literal: slot tag ;

VREG-INSN: set-slot##
use: src/tagged-rep obj/tagged-rep slot/int-rep
literal: scale tag ;

VREG-INSN: set-slot-imm##
use: src/tagged-rep obj/tagged-rep
literal: slot tag ;

! Register transfers
FOLDABLE-INSN: copy##
def: dst
use: src
literal: rep ;

! Only used by compiler.cfg.cssa
FLUSHABLE-INSN: parallel-copy##
literal: values ;

FOLDABLE-INSN: tagged>integer##
def: dst/int-rep
use: src/tagged-rep ;

! Integer arithmetic
FOLDABLE-INSN: add##
def: dst/int-rep
use: src1/int-rep src2/int-rep ;

FOLDABLE-INSN: add-imm##
def: dst/int-rep
use: src1/int-rep
literal: src2 ;

FOLDABLE-INSN: sub##
def: dst/int-rep
use: src1/int-rep src2/int-rep ;

FOLDABLE-INSN: sub-imm##
def: dst/int-rep
use: src1/int-rep
literal: src2 ;

FOLDABLE-INSN: mul##
def: dst/int-rep
use: src1/int-rep src2/int-rep ;

FOLDABLE-INSN: mul-imm##
def: dst/int-rep
use: src1/int-rep
literal: src2 ;

FOLDABLE-INSN: and##
def: dst/int-rep
use: src1/int-rep src2/int-rep ;

FOLDABLE-INSN: and-imm##
def: dst/int-rep
use: src1/int-rep
literal: src2 ;

FOLDABLE-INSN: or##
def: dst/int-rep
use: src1/int-rep src2/int-rep ;

FOLDABLE-INSN: or-imm##
def: dst/int-rep
use: src1/int-rep
literal: src2 ;

FOLDABLE-INSN: xor##
def: dst/int-rep
use: src1/int-rep src2/int-rep ;

FOLDABLE-INSN: xor-imm##
def: dst/int-rep
use: src1/int-rep
literal: src2 ;

FOLDABLE-INSN: shl##
def: dst/int-rep
use: src1/int-rep src2/int-rep ;

FOLDABLE-INSN: shl-imm##
def: dst/int-rep
use: src1/int-rep
literal: src2 ;

FOLDABLE-INSN: shr##
def: dst/int-rep
use: src1/int-rep src2/int-rep ;

FOLDABLE-INSN: shr-imm##
def: dst/int-rep
use: src1/int-rep
literal: src2 ;

FOLDABLE-INSN: sar##
def: dst/int-rep
use: src1/int-rep src2/int-rep ;

FOLDABLE-INSN: sar-imm##
def: dst/int-rep
use: src1/int-rep
literal: src2 ;

FOLDABLE-INSN: min##
def: dst/int-rep
use: src1/int-rep src2/int-rep ;

FOLDABLE-INSN: max##
def: dst/int-rep
use: src1/int-rep src2/int-rep ;

FOLDABLE-INSN: not##
def: dst/int-rep
use: src/int-rep ;

FOLDABLE-INSN: neg##
def: dst/int-rep
use: src/int-rep ;

FOLDABLE-INSN: log2##
def: dst/int-rep
use: src/int-rep ;

FOLDABLE-INSN: bit-count##
def: dst/int-rep
use: src/int-rep ;

FOLDABLE-INSN: bit-test##
def: dst/tagged-rep
use: src1/int-rep src2/int-rep
temp: temp/int-rep ;

! Float arithmetic
FOLDABLE-INSN: add-float##
def: dst/double-rep
use: src1/double-rep src2/double-rep ;

FOLDABLE-INSN: sub-float##
def: dst/double-rep
use: src1/double-rep src2/double-rep ;

FOLDABLE-INSN: mul-float##
def: dst/double-rep
use: src1/double-rep src2/double-rep ;

FOLDABLE-INSN: div-float##
def: dst/double-rep
use: src1/double-rep src2/double-rep ;

FOLDABLE-INSN: min-float##
def: dst/double-rep
use: src1/double-rep src2/double-rep ;

FOLDABLE-INSN: max-float##
def: dst/double-rep
use: src1/double-rep src2/double-rep ;

FOLDABLE-INSN: sqrt##
def: dst/double-rep
use: src/double-rep ;

! Single/double float conversion
FOLDABLE-INSN: single>double-float##
def: dst/double-rep
use: src/float-rep ;

FOLDABLE-INSN: double>single-float##
def: dst/float-rep
use: src/double-rep ;

! Float/integer conversion
FOLDABLE-INSN: float>integer##
def: dst/int-rep
use: src/double-rep ;

FOLDABLE-INSN: integer>float##
def: dst/double-rep
use: src/int-rep ;

! SIMD operations
FOLDABLE-INSN: zero-vector##
def: dst
literal: rep ;

FOLDABLE-INSN: fill-vector##
def: dst
literal: rep ;

FOLDABLE-INSN: gather-vector-2##
def: dst
use: src1/scalar-rep src2/scalar-rep
literal: rep ;

FOLDABLE-INSN: gather-int-vector-2##
def: dst
use: src1/int-rep src2/int-rep
literal: rep ;

FOLDABLE-INSN: gather-vector-4##
def: dst
use: src1/scalar-rep src2/scalar-rep src3/scalar-rep src4/scalar-rep
literal: rep ;

FOLDABLE-INSN: gather-int-vector-4##
def: dst
use: src1/int-rep src2/int-rep src3/int-rep src4/int-rep
literal: rep ;

FOLDABLE-INSN: select-vector##
def: dst/int-rep
use: src
literal: n rep ;

FOLDABLE-INSN: shuffle-vector##
def: dst
use: src shuffle
literal: rep ;

FOLDABLE-INSN: shuffle-vector-halves-imm##
def: dst
use: src1 src2
literal: shuffle rep ;

FOLDABLE-INSN: shuffle-vector-imm##
def: dst
use: src
literal: shuffle rep ;

FOLDABLE-INSN: tail>head-vector##
def: dst
use: src
literal: rep ;

FOLDABLE-INSN: merge-vector-head##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: merge-vector-tail##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: float-pack-vector##
def: dst
use: src
literal: rep ;

FOLDABLE-INSN: signed-pack-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: unsigned-pack-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: unpack-vector-head##
def: dst
use: src
literal: rep ;

FOLDABLE-INSN: unpack-vector-tail##
def: dst
use: src
literal: rep ;

FOLDABLE-INSN: integer>float-vector##
def: dst
use: src
literal: rep ;

FOLDABLE-INSN: float>integer-vector##
def: dst
use: src
literal: rep ;

FOLDABLE-INSN: compare-vector##
def: dst
use: src1 src2
literal: rep cc ;

FOLDABLE-INSN: move-vector-mask##
def: dst/int-rep
use: src
literal: rep ;

FOLDABLE-INSN: test-vector##
def: dst/tagged-rep
use: src1
temp: temp/int-rep
literal: rep vcc ;

VREG-INSN: test-vector-branch##
use: src1
temp: temp/int-rep
literal: rep vcc ;

FOLDABLE-INSN: add-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: saturated-add-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: add-sub-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: sub-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: saturated-sub-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: mul-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: mul-high-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: mul-horizontal-add-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: saturated-mul-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: div-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: min-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: max-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: avg-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: dot-vector##
def: dst/scalar-rep
use: src1 src2
literal: rep ;

FOLDABLE-INSN: sad-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: horizontal-add-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: horizontal-sub-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: horizontal-shl-vector-imm##
def: dst
use: src1
literal: src2 rep ;

FOLDABLE-INSN: horizontal-shr-vector-imm##
def: dst
use: src1
literal: src2 rep ;

FOLDABLE-INSN: abs-vector##
def: dst
use: src
literal: rep ;

FOLDABLE-INSN: sqrt-vector##
def: dst
use: src
literal: rep ;

FOLDABLE-INSN: and-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: andn-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: or-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: xor-vector##
def: dst
use: src1 src2
literal: rep ;

FOLDABLE-INSN: not-vector##
def: dst
use: src
literal: rep ;

FOLDABLE-INSN: shl-vector-imm##
def: dst
use: src1
literal: src2 rep ;

FOLDABLE-INSN: shr-vector-imm##
def: dst
use: src1
literal: src2 rep ;

FOLDABLE-INSN: shl-vector##
def: dst
use: src1 src2/int-scalar-rep
literal: rep ;

FOLDABLE-INSN: shr-vector##
def: dst
use: src1 src2/int-scalar-rep
literal: rep ;

! Scalar/vector conversion
FOLDABLE-INSN: scalar>integer##
def: dst/int-rep
use: src
literal: rep ;

FOLDABLE-INSN: integer>scalar##
def: dst
use: src/int-rep
literal: rep ;

FOLDABLE-INSN: vector>scalar##
def: dst/scalar-rep
use: src
literal: rep ;

FOLDABLE-INSN: scalar>vector##
def: dst
use: src/scalar-rep
literal: rep ;

! Boxing and unboxing aliens
FOLDABLE-INSN: box-alien##
def: dst/tagged-rep
use: src/int-rep
temp: temp/int-rep ;

FOLDABLE-INSN: box-displaced-alien##
def: dst/tagged-rep
use: displacement/int-rep base/tagged-rep
temp: temp/int-rep
literal: base-class ;

FOLDABLE-INSN: unbox-any-c-ptr##
def: dst/int-rep
use: src/tagged-rep ;

FOLDABLE-INSN: unbox-alien##
def: dst/int-rep
use: src/tagged-rep ;

! Zero-extending and sign-extending integers
FOLDABLE-INSN: convert-integer##
def: dst/int-rep
use: src/int-rep
literal: c-type ;

! Raw memory accessors
FLUSHABLE-INSN: load-memory##
def: dst
use: base/int-rep displacement/int-rep
literal: scale offset rep c-type ;

FLUSHABLE-INSN: load-memory-imm##
def: dst
use: base/int-rep
literal: offset rep c-type ;

VREG-INSN: store-memory##
use: src base/int-rep displacement/int-rep
literal: scale offset rep c-type ;

VREG-INSN: store-memory-imm##
use: src base/int-rep
literal: offset rep c-type ;

! Memory allocation
FLUSHABLE-INSN: allot##
def: dst/tagged-rep
literal: size class-of
temp: temp/int-rep ;

VREG-INSN: write-barrier##
use: src/tagged-rep slot/int-rep
literal: scale tag
temp: temp1/int-rep temp2/int-rep ;

VREG-INSN: write-barrier-imm##
use: src/tagged-rep
literal: slot tag
temp: temp1/int-rep temp2/int-rep ;

FLUSHABLE-INSN: alien-global##
def: dst/int-rep
literal: symbol library ;

FLUSHABLE-INSN: vm-field##
def: dst/tagged-rep
literal: offset ;

VREG-INSN: set-vm-field##
use: src/tagged-rep
literal: offset ;

! FFI
FOLDABLE-INSN: unbox##
def: dst
use: src/tagged-rep
literal: unboxer rep ;

FOLDABLE-INSN: unbox-long-long##
def: dst1/int-rep dst2/int-rep
use: src/tagged-rep
literal: unboxer ;

FLUSHABLE-INSN: local-allot##
def: dst/int-rep
literal: size align offset ;

FOLDABLE-INSN: box##
def: dst/tagged-rep
use: src
literal: boxer rep gc-map ;

FOLDABLE-INSN: box-long-long##
def: dst/tagged-rep
use: src1/int-rep src2/int-rep
literal: boxer gc-map ;

! Alien call inputs and outputs are arrays of triples with shape
! { vreg rep stack#/reg }

VREG-INSN: alien-invoke##
literal: varargs? reg-inputs stack-inputs reg-outputs dead-outputs cleanup stack-size symbols dll gc-map ;

VREG-INSN: alien-indirect##
use: src/int-rep
literal: varargs? reg-inputs stack-inputs reg-outputs dead-outputs cleanup stack-size gc-map ;

VREG-INSN: alien-assembly##
literal: varargs? reg-inputs stack-inputs reg-outputs dead-outputs cleanup stack-size quot ;

VREG-INSN: callback-inputs##
literal: reg-outputs stack-outputs ;

VREG-INSN: callback-outputs##
literal: reg-inputs ;

! Control flow
FLUSHABLE-INSN: phi##
def: dst
literal: inputs ;

INSN: branch## ;

! Tagged conditionals
VREG-INSN: compare-branch##
use: src1/tagged-rep src2/tagged-rep
literal: cc ;

VREG-INSN: compare-imm-branch##
use: src1/tagged-rep
literal: src2 cc ;

FOLDABLE-INSN: compare##
def: dst/tagged-rep
use: src1/tagged-rep src2/tagged-rep
literal: cc
temp: temp/int-rep ;

FOLDABLE-INSN: compare-imm##
def: dst/tagged-rep
use: src1/tagged-rep
literal: src2 cc
temp: temp/int-rep ;

! Integer conditionals
VREG-INSN: compare-integer-branch##
use: src1/int-rep src2/int-rep
literal: cc ;

VREG-INSN: compare-integer-imm-branch##
use: src1/int-rep
literal: src2 cc ;

VREG-INSN: test-branch##
use: src1/int-rep src2/int-rep
literal: cc ;

VREG-INSN: test-imm-branch##
use: src1/int-rep
literal: src2 cc ;

FOLDABLE-INSN: compare-integer##
def: dst/tagged-rep
use: src1/int-rep src2/int-rep
literal: cc
temp: temp/int-rep ;

FOLDABLE-INSN: compare-integer-imm##
def: dst/tagged-rep
use: src1/int-rep
literal: src2 cc
temp: temp/int-rep ;

FOLDABLE-INSN: test##
def: dst/tagged-rep
use: src1/int-rep src2/int-rep
literal: cc
temp: temp/int-rep ;

FOLDABLE-INSN: test-imm##
def: dst/tagged-rep
use: src1/int-rep
literal: src2 cc
temp: temp/int-rep ;

! Float conditionals
VREG-INSN: compare-float-ordered-branch##
use: src1/double-rep src2/double-rep
literal: cc ;

VREG-INSN: compare-float-unordered-branch##
use: src1/double-rep src2/double-rep
literal: cc ;

FOLDABLE-INSN: compare-float-ordered##
def: dst/tagged-rep
use: src1/double-rep src2/double-rep
literal: cc
temp: temp/int-rep ;

FOLDABLE-INSN: compare-float-unordered##
def: dst/tagged-rep
use: src1/double-rep src2/double-rep
literal: cc
temp: temp/int-rep ;

! Overflowing arithmetic
VREG-INSN: fixnum-add##
def: dst/tagged-rep
use: src1/tagged-rep src2/tagged-rep
literal: cc ;

VREG-INSN: fixnum-sub##
def: dst/tagged-rep
use: src1/tagged-rep src2/tagged-rep
literal: cc ;

VREG-INSN: fixnum-mul##
def: dst/tagged-rep
use: src1/tagged-rep src2/int-rep
literal: cc ;

VREG-INSN: save-context##
temp: temp1/int-rep temp2/int-rep ;

! GC checks
VREG-INSN: check-nursery-branch##
literal: size cc
temp: temp1/int-rep temp2/int-rep ;

INSN: call-gc##
literal: gc-map ;

! Spills and reloads, inserted by register allocator
TUPLE: spill-slot { n integer } ;
C: <spill-slot> spill-slot

VREG-INSN: spill##
use: src
literal: rep dst ;

VREG-INSN: reload##
def: dst
literal: rep src ;

UNION: allocation-insn
    allot##
    box-alien##
    box-displaced-alien## ;

UNION: conditional-branch-insn
    compare-branch##
    compare-imm-branch##
    compare-integer-branch##
    compare-integer-imm-branch##
    test-branch##
    test-imm-branch##
    compare-float-ordered-branch##
    compare-float-unordered-branch##
    test-vector-branch##
    check-nursery-branch##
    fixnum-add##
    fixnum-sub##
    fixnum-mul## ;

! For alias analysis
UNION: read-insn slot## slot-imm## vm-field## alien-global## ;
UNION: write-insn set-slot## set-slot-imm## set-vm-field## ;

UNION: alien-call-insn
    alien-assembly##
    alien-indirect##
    alien-invoke## ;

UNION: gc-map-insn
    call-gc##
    box##
    box-long-long##
    alien-indirect##
    alien-invoke## ;

M: gc-map-insn clone call-next-method [ clone ] change-gc-map ;

TUPLE: gc-map gc-roots derived-roots ;

: <gc-map> ( -- gc-map ) gc-map new ;

UNION: def-is-use-insn
    box-alien##
    box-displaced-alien##
    unbox-any-c-ptr## ;