cpu.architecture vocabulary
Factor handbook > Vocabulary index


Documentation
CPU architecture description model

Meta-data
Tags:compiler
Authors:Slava Pestov


Words

Singleton classes
any-rep
char-16-rep
char-scalar-rep
double-2-rep
double-rep
float-4-rep
float-regs
float-rep
int-4-rep
int-regs
int-rep
int-scalar-rep
longlong-2-rep
longlong-scalar-rep
short-8-rep
short-scalar-rep
tagged-rep
uchar-16-rep
uchar-scalar-rep
uint-4-rep
uint-scalar-rep
ulonglong-2-rep
ulonglong-scalar-rep
ushort-8-rep
ushort-scalar-rep


Union classes
float-vector-rep
int-vector-rep
reg-class
representation
scalar-rep
signed-int-vector-rep
unsigned-int-vector-rep
vector-rep


Generic words
WordStack effect
%abs-vector( dst src rep -- )
%abs-vector-reps( -- reps )
%add( dst src1 src2 -- )
%add-float( dst src1 src2 -- )
%add-imm( dst src1 src2 -- )
%add-sub-vector( dst src1 src2 rep -- )
%add-sub-vector-reps( -- reps )
%add-vector( dst src1 src2 rep -- )
%add-vector-reps( -- reps )
%alien-assembly( varargs? reg-inputs stack-inputs reg-outputs dead-outputs cleanup stack-size quot -- )
%alien-global( dst symbol library -- )
%alien-indirect( src varargs? reg-inputs stack-inputs reg-outputs dead-outputs cleanup stack-size gc-map -- )
%alien-invoke( varargs? reg-inputs stack-inputs reg-outputs dead-outputs cleanup stack-size symbols dll gc-map -- )
%alien-vector-reps( -- reps )
%allot( dst size class temp -- )
%and( dst src1 src2 -- )
%and-imm( dst src1 src2 -- )
%and-vector( dst src1 src2 rep -- )
%and-vector-reps( -- reps )
%andn-vector( dst src1 src2 rep -- )
%andn-vector-reps( -- reps )
%avg-vector( dst src1 src2 rep -- )
%avg-vector-reps( -- reps )
%bit-count( dst src -- )
%bit-test( dst src1 src2 temp -- )
%box( dst src func rep gc-map -- )
%box-alien( dst src temp -- )
%box-displaced-alien( dst displacement base temp base-class -- )
%box-long-long( dst src1 src2 func gc-map -- )
%c-invoke( symbols dll gc-map -- )
%call( word -- )
%call-gc( gc-map -- )
%callback-inputs( reg-outputs stack-outputs -- )
%callback-outputs( reg-inputs -- )
%check-nursery-branch( label size cc temp1 temp2 -- )
%clear( loc -- )
%compare( dst src1 src2 cc temp -- )
%compare-branch( label cc src1 src2 -- )
%compare-float-ordered( dst src1 src2 cc temp -- )
%compare-float-ordered-branch( label cc src1 src2 -- )
%compare-float-unordered( dst src1 src2 cc temp -- )
%compare-float-unordered-branch( label cc src1 src2 -- )
%compare-imm( dst src1 src2 cc temp -- )
%compare-imm-branch( label cc src1 src2 -- )
%compare-integer-imm( dst src1 src2 cc temp -- )
%compare-integer-imm-branch( label cc src1 src2 -- )
%compare-vector( dst src1 src2 rep cc -- )
%compare-vector-ccs( rep cc -- {cc,swap?}s not? )
%compare-vector-reps( cc -- reps )
%convert-integer( dst src c-type -- )
%copy( dst src rep -- )
%dispatch( src temp -- )
%div-float( dst src1 src2 -- )
%div-vector( dst src1 src2 rep -- )
%div-vector-reps( -- reps )
%dot-vector( dst src1 src2 rep -- )
%dot-vector-reps( -- reps )
%double>single-float( dst src -- )
%epilogue( n -- )
%fill-vector( dst rep -- )
%fill-vector-reps( -- reps )
%fixnum-add( label dst src1 src2 cc -- )
%fixnum-mul( label dst src1 src2 cc -- )
%fixnum-sub( label dst src1 src2 cc -- )
%float-pack-vector( dst src rep -- )
%float-pack-vector-reps( -- reps )
%float>integer( dst src -- )
%float>integer-vector( dst src rep -- )
%float>integer-vector-reps( -- reps )
%gather-int-vector-2( dst src1 src2 rep -- )
%gather-int-vector-2-reps( -- reps )
%gather-int-vector-4( dst src1 src2 src3 src4 rep -- )
%gather-int-vector-4-reps( -- reps )
%gather-vector-2( dst src1 src2 rep -- )
%gather-vector-2-reps( -- reps )
%gather-vector-4( dst src1 src2 src3 src4 rep -- )
%gather-vector-4-reps( -- reps )
%horizontal-add-vector( dst src1 src2 rep -- )
%horizontal-add-vector-reps( -- reps )
%horizontal-shl-vector-imm( dst src1 src2 rep -- )
%horizontal-shl-vector-imm-reps( -- reps )
%horizontal-shr-vector-imm( dst src1 src2 rep -- )
%horizontal-shr-vector-imm-reps( -- reps )
%horizontal-sub-vector( dst src1 src2 rep -- )
%horizontal-sub-vector-reps( -- reps )
%inc( loc -- )
%integer>float( dst src -- )
%integer>float-vector( dst src rep -- )
%integer>float-vector-reps( -- reps )
%integer>scalar( dst src rep -- )
%jump( word -- )
%jump-label( label -- )
%load-double( reg val -- )
%load-float( reg val -- )
%load-immediate( reg val -- )
%load-memory( dst base displacement scale offset rep c-type -- )
%load-memory-imm( dst base offset rep c-type -- )
%load-reference( reg obj -- )
%load-vector( reg val rep -- )
%local-allot( dst size align offset -- )
%log2( dst src -- )
%max( dst src1 src2 -- )
%max-float( dst src1 src2 -- )
%max-vector( dst src1 src2 rep -- )
%max-vector-reps( -- reps )
%merge-vector-head( dst src1 src2 rep -- )
%merge-vector-reps( -- reps )
%merge-vector-tail( dst src1 src2 rep -- )
%min( dst src1 src2 -- )
%min-float( dst src1 src2 -- )
%min-vector( dst src1 src2 rep -- )
%min-vector-reps( -- reps )
%move-vector-mask( dst src rep -- )
%move-vector-mask-reps( -- reps )
%mul( dst src1 src2 -- )
%mul-float( dst src1 src2 -- )
%mul-high-vector( dst src1 src2 rep -- )
%mul-high-vector-reps( -- reps )
%mul-horizontal-add-vector( dst src1 src2 rep -- )
%mul-horizontal-add-vector-reps( -- reps )
%mul-imm( dst src1 src2 -- )
%mul-vector( dst src1 src2 rep -- )
%mul-vector-reps( -- reps )
%neg( dst src -- )
%not( dst src -- )
%not-vector( dst src rep -- )
%not-vector-reps( -- reps )
%or( dst src1 src2 -- )
%or-imm( dst src1 src2 -- )
%or-vector( dst src1 src2 rep -- )
%or-vector-reps( -- reps )
%peek( vreg loc -- )
%prologue( n -- )
%reload( dst rep src -- )
%replace( vreg loc -- )
%replace-imm( src loc -- )
%return( -- )
%sad-vector( dst src1 src2 rep -- )
%sad-vector-reps( -- reps )
%safepoint( -- )
%sar( dst src1 src2 -- )
%sar-imm( dst src1 src2 -- )
%saturated-add-vector( dst src1 src2 rep -- )
%saturated-add-vector-reps( -- reps )
%saturated-mul-vector( dst src1 src2 rep -- )
%saturated-mul-vector-reps( -- reps )
%saturated-sub-vector( dst src1 src2 rep -- )
%saturated-sub-vector-reps( -- reps )
%save-context( temp1 temp2 -- )
%scalar>integer( dst src rep -- )
%scalar>vector( dst src rep -- )
%select-vector( dst src n rep -- )
%select-vector-reps( -- reps )
%set-slot( src obj slot scale tag -- )
%set-slot-imm( src obj slot tag -- )
%set-vm-field( src offset -- )
%shl( dst src1 src2 -- )
%shl-imm( dst src1 src2 -- )
%shl-vector( dst src1 src2 rep -- )
%shl-vector-imm( dst src1 src2 rep -- )
%shl-vector-imm-reps( -- reps )
%shl-vector-reps( -- reps )
%shr( dst src1 src2 -- )
%shr-imm( dst src1 src2 -- )
%shr-vector( dst src1 src2 rep -- )
%shr-vector-imm( dst src1 src2 rep -- )
%shr-vector-imm-reps( -- reps )
%shr-vector-reps( -- reps )
%shuffle-vector( dst src shuffle rep -- )
%shuffle-vector-halves-imm( dst src1 src2 shuffle rep -- )
%shuffle-vector-halves-imm-reps( -- reps )
%shuffle-vector-imm( dst src shuffle rep -- )
%shuffle-vector-imm-reps( -- reps )
%shuffle-vector-reps( -- reps )
%signed-pack-vector( dst src1 src2 rep -- )
%signed-pack-vector-reps( -- reps )
%single>double-float( dst src -- )
%slot( dst obj slot scale tag -- )
%slot-imm( dst obj slot tag -- )
%spill( src rep dst -- )
%sqrt( dst src -- )
%sqrt-vector( dst src rep -- )
%sqrt-vector-reps( -- reps )
%store-memory( value base displacement scale offset rep c-type -- )
%store-memory-imm( value base offset rep c-type -- )
%sub( dst src1 src2 -- )
%sub-float( dst src1 src2 -- )
%sub-imm( dst src1 src2 -- )
%sub-vector( dst src1 src2 rep -- )
%sub-vector-reps( -- reps )
%tail>head-vector( dst src rep -- )
%test( dst src1 src2 cc temp -- )
%test-branch( label cc src1 src2 -- )
%test-imm( dst src1 src2 cc temp -- )
%test-imm-branch( label cc src1 src2 -- )
%test-vector( dst src1 temp rep vcc -- )
%test-vector-branch( label src1 temp rep vcc -- )
%test-vector-reps( -- reps )
%unbox( dst src func rep -- )
%unbox-alien( dst src -- )
%unbox-any-c-ptr( dst src -- )
%unbox-long-long( dst1 dst2 src func -- )
%unpack-vector-head( dst src rep -- )
%unpack-vector-head-reps( -- reps )
%unpack-vector-tail( dst src rep -- )
%unpack-vector-tail-reps( -- reps )
%unsigned-pack-vector( dst src1 src2 rep -- )
%unsigned-pack-vector-reps( -- reps )
%vector>scalar( dst src rep -- )
%vm-field( dst offset -- )
%write-barrier( src slot scale tag temp1 temp2 -- )
%write-barrier-imm( src slot tag temp1 temp2 -- )
%xor( dst src1 src2 -- )
%xor-imm( dst src1 src2 -- )
%xor-vector( dst src1 src2 rep -- )
%xor-vector-reps( -- reps )
%zero-vector( dst rep -- )
%zero-vector-reps( -- reps )
complex-addressing?( -- ? )
dummy-fp-params?( -- ? )
dummy-int-params?( -- ? )
dummy-stack-params?( -- ? )
enable-cpu-features( -- )
float-right-align-on-stack?( -- ? )
frame-reg( -- reg )
fused-unboxing?( -- ? )
gc-root-offset( spill-slot -- n )
immediate-arithmetic?( n -- ? )
immediate-bitwise?( n -- ? )
immediate-comparand?( n -- ? )
immediate-store?( obj -- ? )
integer-float-needs-stack-frame?( -- ? )
long-long-odd-register?( -- ? )
long-long-on-stack?( -- ? )
machine-registers( -- assoc )
param-regs( abi -- regs )
reg-class-of( rep -- reg-class )
rep-component-type( rep -- n )
rep-length( rep -- n )
rep-size( rep -- n )
return-regs( -- regs )
return-struct-in-registers?( c-type -- ? )
scalar-rep-of( rep -- rep' )
stack-cleanup( stack-size return abi -- n )
stack-frame-size( stack-frame -- n )
struct-return-on-stack?( -- ? )
test-instruction?( -- ? )
value-struct?( c-type -- ? )
vm-stack-space( -- n )


Ordinary words
WordStack effect
%context( dst -- )
%merge-vector-head-reps( -- reps )
%merge-vector-tail-reps( -- reps )
%tagged>integer( dst src -- )
%tail>head-vector-reps( -- reps )
ex-%allot( -- string )
ex-%box-alien( -- string )
ex-%context( -- string )
ex-%copy( -- string )
ex-%safepoint( -- string )
ex-%save-context( -- string )
ex-%write-barrier( -- string )
immediate-shift-count?( n -- ? )
narrow-vector-rep( rep -- rep' )
reg-classes( -- value )
signed-rep( rep -- rep' )
vector-reps( -- value )
widen-vector-rep( rep -- rep' )


Class predicate words
WordStack effect
any-rep?( object -- ? )
char-16-rep?( object -- ? )
char-scalar-rep?( object -- ? )
double-2-rep?( object -- ? )
double-rep?( object -- ? )
float-4-rep?( object -- ? )
float-regs?( object -- ? )
float-rep?( object -- ? )
float-vector-rep?( object -- ? )
int-4-rep?( object -- ? )
int-regs?( object -- ? )
int-rep?( object -- ? )
int-scalar-rep?( object -- ? )
int-vector-rep?( object -- ? )
longlong-2-rep?( object -- ? )
longlong-scalar-rep?( object -- ? )
reg-class?( object -- ? )
representation?( object -- ? )
scalar-rep?( object -- ? )
short-8-rep?( object -- ? )
short-scalar-rep?( object -- ? )
signed-int-vector-rep?( object -- ? )
tagged-rep?( object -- ? )
uchar-16-rep?( object -- ? )
uchar-scalar-rep?( object -- ? )
uint-4-rep?( object -- ? )
uint-scalar-rep?( object -- ? )
ulonglong-2-rep?( object -- ? )
ulonglong-scalar-rep?( object -- ? )
unsigned-int-vector-rep?( object -- ? )
ushort-8-rep?( object -- ? )
ushort-scalar-rep?( object -- ? )
vector-rep?( object -- ? )


Files