3.1.10 v8 Languages

exprs-lang-v8 : grammar?

p	::=	(module (define x (lambda (x ...) value)) ... value)

value	::=	triv
	\|	(let ([x value] ...) value)
	\|	(if value value value)
	\|	(call value value ...)

triv	::=	x
	\|	fixnum
	\|	#t
	\|	#f
	\|	empty
	\|	(void)
	\|	(error uint8)
	\|	ascii-char-literal

x	::=	name?
	\|	prim-f

prim-f	::=	*
	\|	+
	\|	-
	\|	<
	\|	<=
	\|	>
	\|	>=
	\|	eq?
	\|	fixnum?
	\|	boolean?
	\|	empty?
	\|	void?
	\|	ascii-char?
	\|	error?
	\|	not
	\|	pair?
	\|	vector?
	\|	cons
	\|	car
	\|	cdr
	\|	make-vector
	\|	vector-length
	\|	vector-set!
	\|	vector-ref

uint8	::=	uint8?

ascii-char-literal	::=	ascii-char-literal?

fixnum	::=	int61?

procedure
(exprs-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the exprs-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-exprs-lang-v8 a) → any/c
a : exprs-lang-v8?

Evaluates a exprs-lang-v8 program to a value.

exprs-unique-lang-v8 : grammar?

p	::=	(module (define label (lambda (aloc ...) value)) ... value)

value	::=	triv
	\|	(call value value ...)
	\|	(let ([aloc value] ...) value)
	\|	(if value value value)

triv	::=	label
	\|	aloc
	\|	prim-f
	\|	fixnum
	\|	#t
	\|	#f
	\|	empty
	\|	(void)
	\|	(error uint8)
	\|	ascii-char-literal

prim-f	::=	*
	\|	+
	\|	-
	\|	<
	\|	<=
	\|	>
	\|	>=
	\|	eq?
	\|	fixnum?
	\|	boolean?
	\|	empty?
	\|	void?
	\|	ascii-char?
	\|	error?
	\|	not
	\|	pair?
	\|	vector?
	\|	cons
	\|	car
	\|	cdr
	\|	make-vector
	\|	vector-length
	\|	vector-set!
	\|	vector-ref

aloc	::=	aloc?

label	::=	label?

fixnum	::=	int61?

uint8	::=	uint8?

ascii-char-literal	::=	ascii-char-literal?

procedure
(exprs-unique-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the exprs-unique-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-exprs-unique-lang-v8 a) → any/c
a : exprs-unique-lang-v8?

Evaluates a exprs-unique-lang-v8 program to a value.

exprs-unsafe-data-lang-v8 : grammar?

p	::=	(module (define label (lambda (aloc ...) value)) ... value)

value	::=	triv
	\|	(primop value ...)
	\|	(call value value ...)
	\|	(let ([aloc value] ...) value)
	\|	(if value value value)
	\|	(begin effect ... value)

effect	::=	(primop value ...)
	\|	(begin effect ... effect)

triv	::=	label
	\|	aloc
	\|	fixnum
	\|	#t
	\|	#f
	\|	empty
	\|	(void)
	\|	(error uint8)
	\|	ascii-char-literal

primop	::=	unsafe-fx*
	\|	unsafe-fx+
	\|	unsafe-fx-
	\|	eq?
	\|	unsafe-fx<
	\|	unsafe-fx<=
	\|	unsafe-fx>
	\|	unsafe-fx>=
	\|	fixnum?
	\|	boolean?
	\|	empty?
	\|	void?
	\|	ascii-char?
	\|	error?
	\|	not
	\|	pair?
	\|	vector?
	\|	cons
	\|	unsafe-car
	\|	unsafe-cdr
	\|	unsafe-make-vector
	\|	unsafe-vector-length
	\|	unsafe-vector-set!
	\|	unsafe-vector-ref

aloc	::=	aloc?

label	::=	label?

fixnum	::=	int61?

uint8	::=	uint8?

ascii-char-literal	::=	ascii-char-literal?

procedure
(exprs-unsafe-data-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the exprs-unsafe-data-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-exprs-unsafe-data-lang-v8 a) → any/c
a : exprs-unsafe-data-lang-v8?

Evaluates a exprs-unsafe-data-lang-v8 program to a value.

exprs-bits-lang-v8 : grammar?

p	::=	(module (define label (lambda (aloc ...) value)) ... value)

pred	::=	(relop value value)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(let ([aloc value] ...) pred)
	\|	(if pred pred pred)
	\|	(begin effect ... pred)

value	::=	triv
	\|	(binop value value)
	\|	(mref value value)
	\|	(alloc value)
	\|	(call value value ...)
	\|	(let ([aloc value] ...) value)
	\|	(if pred value value)
	\|	(begin effect ... value)

effect	::=	(mset! value value value)
	\|	(begin effect ... effect)

triv	::=	label
	\|	aloc
	\|	int64

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

aloc	::=	aloc?

label	::=	label?

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

procedure
(exprs-bits-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the exprs-bits-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-exprs-bits-lang-v8 a) → any/c
a : exprs-bits-lang-v8?

Evaluates a exprs-bits-lang-v8 program to a value.

exprs-bits-lang-v8/contexts : grammar?

p	::=	(module (define label (lambda (aloc ...) tail)) ... tail)

pred	::=	(relop value value)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(let ([aloc value] ...) pred)
	\|	(if pred pred pred)
	\|	(begin effect ... pred)

tail	::=	value
	\|	(let ([aloc value] ...) tail)
	\|	(if pred tail tail)
	\|	(begin effect ... tail)

value	::=	triv
	\|	(binop value value)
	\|	(mref value value)
	\|	(alloc value)
	\|	(call value value ...)
	\|	(let ([aloc value] ...) value)
	\|	(if pred value value)
	\|	(begin effect ... value)

effect	::=	(mset! value value value)
	\|	(begin effect ... effect)

triv	::=	label
	\|	aloc
	\|	int64

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

aloc	::=	aloc?

label	::=	label?

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

procedure
(exprs-bits-lang-v8/contexts? a) → boolean?
a : any/c

Decides whether a is a valid program in the exprs-bits-lang-v8/contexts grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-exprs-bits-lang-v8/contexts a) → any/c
a : exprs-bits-lang-v8/contexts?

Evaluates a exprs-bits-lang-v8/contexts program to a value.

values-bits-lang-v8 : grammar?

p	::=	(module (define label (lambda (aloc ...) tail)) ... tail)

pred	::=	(relop opand opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(let ([aloc value] ...) pred)
	\|	(if pred pred pred)
	\|	(begin effect ... pred)

tail	::=	value
	\|	(let ([aloc value] ...) tail)
	\|	(if pred tail tail)
	\|	(call triv opand ...)
	\|	(begin effect ... tail)

value	::=	triv
	\|	(binop opand opand)
	\|	(mref aloc opand)
	\|	(alloc opand)
	\|	(let ([aloc value] ...) value)
	\|	(if pred value value)
	\|	(call triv opand ...)
	\|	(begin effect ... value)

effect	::=	(mset! aloc opand value)
	\|	(let ([aloc value] ...) effect)
	\|	(begin effect ... effect)

opand	::=	int64
	\|	aloc

triv	::=	opand
	\|	label

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

aloc	::=	aloc?

label	::=	label?

procedure
(values-bits-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the values-bits-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-values-bits-lang-v8 a) → any/c
a : values-bits-lang-v8?

Evaluates a values-bits-lang-v8 program to a value.

imp-mf-lang-v8 : grammar?

p	::=	(module (define label (lambda (aloc ...) tail)) ... tail)

pred	::=	(relop opand opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	value
	\|	(call triv opand ...)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

value	::=	triv
	\|	(call triv opand ...)
	\|	(binop opand opand)
	\|	(mref aloc opand)
	\|	(alloc opand)
	\|	(begin effect ... value)
	\|	(if pred value value)

effect	::=	(set! aloc value)
	\|	(mset! aloc opand value)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)

opand	::=	int64
	\|	aloc

triv	::=	opand
	\|	label

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

aloc	::=	aloc?

label	::=	label?

int64	::=	int64?

procedure
(imp-mf-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the imp-mf-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-imp-mf-lang-v8 a) → any/c
a : imp-mf-lang-v8?

Evaluates a imp-mf-lang-v8 program to a value.

proc-imp-cmf-lang-v8 : grammar?

p

::=

(module (define label (lambda (aloc ...) entry)) ...

entry)

entry

::=

tail

pred

::=

(relop opand opand)

|

(true)

|

(false)

|

(not pred)

|

(begin effect ... pred)

|

(if pred pred pred)

tail

::=

value

|

(call triv opand ...)

|

(begin effect ... tail)

|

(if pred tail tail)

value

::=

triv

|

(binop opand opand)

|

(mref aloc opand)

|

(alloc opand)

|

(call triv opand ...)

effect

::=

(set! aloc value)

|

(mset! aloc opand triv)

|

(begin effect ... effect)

|

(if pred effect effect)

opand

::=

int64

|

aloc

triv

::=

opand

|

label

binop

::=

*

|

+

|

-

|

bitwise-and

|

bitwise-ior

|

bitwise-xor

|

arithmetic-shift-right

relop

::=

<

|

<=

|

=

|

>=

|

>

|

!=

int64

::=

int64?

aloc

::=

aloc?

label

::=

label?

procedure
(proc-imp-cmf-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the proc-imp-cmf-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-proc-imp-cmf-lang-v8 a) → any/c
a : proc-imp-cmf-lang-v8?

Evaluates a proc-imp-cmf-lang-v8 program to a value.

imp-cmf-lang-v8 : grammar?

p	::=	(module info (define label info tail) ... tail)

info	::=	(#:from-contract (info/c (new-frames (frame ...))))

frame	::=	(aloc ...)

pred	::=	(relop opand opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg loc ...)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

value	::=	triv
	\|	(binop opand opand)
	\|	(mref loc opand)
	\|	(alloc opand)

effect	::=	(set! loc value)
	\|	(mset! loc opand triv)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	int64
	\|	loc

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	label
	\|	loc

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

procedure
(imp-cmf-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the imp-cmf-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-imp-cmf-lang-v8 a) → any/c
a : imp-cmf-lang-v8?

Evaluates a imp-cmf-lang-v8 program to a value.

asm-alloc-lang-v8 : grammar?

p	::=	(module info (define label info tail) ... tail)

info	::=	(#:from-contract (info/c (new-frames (frame ...))))

frame	::=	(aloc ...)

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg loc ...)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(set! loc (alloc index))
	\|	(mset! loc index triv)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	int64
	\|	loc

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	label
	\|	loc

index	::=	int64
	\|	loc

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

procedure
(asm-alloc-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the asm-alloc-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-asm-alloc-lang-v8 a) → any/c
a : asm-alloc-lang-v8?

Evaluates a asm-alloc-lang-v8 program to a value.

asm-pred-lang-v8 : grammar?

p	::=	(module info (define label info tail) ... tail)

info	::=	(#:from-contract (info/c (new-frames (frame ...))))

frame	::=	(aloc ...)

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg loc ...)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc index triv)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	int64
	\|	loc

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	label
	\|	loc

index	::=	int64
	\|	loc

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

procedure
(asm-pred-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the asm-pred-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-asm-pred-lang-v8 a) → any/c
a : asm-pred-lang-v8?

Evaluates a asm-pred-lang-v8 program to a value.

asm-pred-lang-v8/locals : grammar?

p	::=	(module info (define label info tail) ... tail)

info	::=	(#:from-contract (info/c (new-frames (frame ...)) (locals (aloc ...))))

frame	::=	(aloc ...)

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg loc ...)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(begin effect ... effect)
	\|	(mset! loc index triv)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	int64
	\|	loc

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	label
	\|	loc

index	::=	int64
	\|	loc

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

procedure
(asm-pred-lang-v8/locals? a) → boolean?
a : any/c

Decides whether a is a valid program in the asm-pred-lang-v8/locals grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-asm-pred-lang-v8/locals a) → any/c
a : asm-pred-lang-v8/locals?

Evaluates a asm-pred-lang-v8/locals program to a value.

asm-pred-lang-v8/undead : grammar?

p	::=	(module info (define label info tail) ... tail)

info	::=	(#:from-contract (info/c (new-frames (frame ...)) (locals (aloc ...)) (call-undead (loc ...)) (undead-out undead-set-tree/rloc?)))

frame	::=	(aloc ...)

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg loc ...)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc index triv)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	int64
	\|	loc

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	label
	\|	loc

index	::=	int64
	\|	loc

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

procedure
(asm-pred-lang-v8/undead? a) → boolean?
a : any/c

Decides whether a is a valid program in the asm-pred-lang-v8/undead grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-asm-pred-lang-v8/undead a) → any/c
a : asm-pred-lang-v8/undead?

Evaluates a asm-pred-lang-v8/undead program to a value.

asm-pred-lang-v8/conflicts : grammar?

p	::=	(module info (define label info tail) ... tail)

info	::=	(#:from-contract (info/c (new-frames (frame ...)) (locals (aloc ...)) (call-undead (loc ...)) (conflicts ((loc (loc ...)) ...))))

frame	::=	(aloc ...)

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg loc ...)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc index triv)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	int64
	\|	loc

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	label
	\|	loc

index	::=	int64
	\|	loc

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

procedure
(asm-pred-lang-v8/conflicts? a) → boolean?
a : any/c

Decides whether a is a valid program in the asm-pred-lang-v8/conflicts grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-asm-pred-lang-v8/conflicts a) → any/c
a : asm-pred-lang-v8/conflicts?

Evaluates a asm-pred-lang-v8/conflicts program to a value.

asm-pred-lang-v8/pre-framed : grammar?

p	::=	(module info (define label info tail) ... tail)

info	::=	(#:from-contract (info/c (new-frames (frame ...)) (locals (aloc ...)) (call-undead (loc ...)) (conflicts ((loc (loc ...)) ...)) (assignment ((aloc loc) ...))))

frame	::=	(aloc ...)

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg loc ...)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc index triv)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	int64
	\|	loc

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	label
	\|	loc

index	::=	int64
	\|	loc

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

procedure
(asm-pred-lang-v8/pre-framed? a) → boolean?
a : any/c

Decides whether a is a valid program in the asm-pred-lang-v8/pre-framed grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-asm-pred-lang-v8/pre-framed a) → any/c
a : asm-pred-lang-v8/pre-framed?

Evaluates a asm-pred-lang-v8/pre-framed program to a value.

asm-pred-lang-v8/framed : grammar?

p	::=	(module info (define label info tail) ... tail)

info	::=	(#:from-contract (info/c (locals (aloc ...)) (conflicts ((loc (loc ...)) ...)) (assignment ((aloc loc) ...))))

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg loc ...)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc index triv)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	int64
	\|	loc

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	label
	\|	loc

index	::=	int64
	\|	loc

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

procedure
(asm-pred-lang-v8/framed? a) → boolean?
a : any/c

Decides whether a is a valid program in the asm-pred-lang-v8/framed grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-asm-pred-lang-v8/framed a) → any/c
a : asm-pred-lang-v8/framed?

Evaluates a asm-pred-lang-v8/framed program to a value.

asm-pred-lang-v8/spilled : grammar?

p	::=	(module info (define label info tail) ... tail)

info	::=	(#:from-contract (info/c (locals (aloc ...)) (conflicts ((loc (loc ...)) ...)) (assignment ((aloc loc) ...))))

frame	::=	(aloc ...)

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg loc ...)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc index triv)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	int64
	\|	loc

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	label
	\|	loc

index	::=	int64
	\|	loc

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

procedure
(asm-pred-lang-v8/spilled? a) → boolean?
a : any/c

Decides whether a is a valid program in the asm-pred-lang-v8/spilled grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-asm-pred-lang-v8/spilled a) → any/c
a : asm-pred-lang-v8/spilled?

Evaluates a asm-pred-lang-v8/spilled program to a value.

asm-pred-lang-v8/assignments : grammar?

p	::=	(module info (define label info tail) ... tail)

info	::=	(#:from-contract (info/c (assignment ((aloc loc) ...))))

frame	::=	(aloc ...)

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg loc ...)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc index triv)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	int64
	\|	loc

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	label
	\|	loc

index	::=	int64
	\|	loc

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

procedure
(asm-pred-lang-v8/assignments? a) → boolean?
a : any/c

Decides whether a is a valid program in the asm-pred-lang-v8/assignments grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-asm-pred-lang-v8/assignments a) → any/c
a : asm-pred-lang-v8/assignments?

Evaluates a asm-pred-lang-v8/assignments program to a value.

nested-asm-lang-fvars-v8 : grammar?

p	::=	(module (define label tail) ... tail)

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc index triv)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)
	\|	(return-point label tail)

triv	::=	opand
	\|	label

opand	::=	int64
	\|	loc

trg	::=	label
	\|	loc

loc	::=	reg
	\|	fvar

index	::=	int64
	\|	loc

reg	::=	rsp
	\|	rbp
	\|	rax
	\|	rbx
	\|	rcx
	\|	rdx
	\|	rsi
	\|	rdi
	\|	r8
	\|	r9
	\|	r12
	\|	r13
	\|	r14
	\|	r15

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

aloc	::=	aloc?

fvar	::=	fvar?

label	::=	label?

procedure
(nested-asm-lang-fvars-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the nested-asm-lang-fvars-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-nested-asm-lang-fvars-v8 a) → any/c
a : nested-asm-lang-fvars-v8?

Evaluates a nested-asm-lang-fvars-v8 program to a value.

nested-asm-lang-v8 : grammar?

p	::=	(module (define label tail) ... tail)

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(begin effect ... pred)
	\|	(if pred pred pred)

tail	::=	(jump trg)
	\|	(begin effect ... tail)
	\|	(if pred tail tail)

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc index triv)
	\|	(begin effect ... effect)
	\|	(if pred effect effect)
	\|	(return-point label tail)

triv	::=	opand
	\|	label

opand	::=	int64
	\|	loc

trg	::=	label
	\|	loc

loc	::=	reg
	\|	addr

index	::=	int64
	\|	loc

reg	::=	rsp
	\|	rbp
	\|	rax
	\|	rbx
	\|	rcx
	\|	rdx
	\|	rsi
	\|	rdi
	\|	r8
	\|	r9
	\|	r12
	\|	r13
	\|	r14
	\|	r15

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

addr	::=	(fbp - dispoffset)

fbp	::=	frame-base-pointer-register?

dispoffset	::=	dispoffset?

label	::=	label?

procedure
(nested-asm-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the nested-asm-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-nested-asm-lang-v8 a) → any/c
a : nested-asm-lang-v8?

Evaluates a nested-asm-lang-v8 program to a value.

block-pred-lang-v8 : grammar?

p	::=	(module b ... b)

b	::=	(define label tail)

pred	::=	(relop loc opand)
	\|	(true)
	\|	(false)
	\|	(not pred)

tail	::=	(jump trg)
	\|	(begin s ... tail)
	\|	(if pred (jump trg) (jump trg))

s	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc index triv)

triv	::=	opand
	\|	label

opand	::=	int64
	\|	loc

trg	::=	label
	\|	loc

loc	::=	reg
	\|	addr

index	::=	int64
	\|	loc

reg	::=	rsp
	\|	rbp
	\|	rax
	\|	rbx
	\|	rcx
	\|	rdx
	\|	rsi
	\|	rdi
	\|	r8
	\|	r9
	\|	r12
	\|	r13
	\|	r14
	\|	r15

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

addr	::=	(fbp - dispoffset)

fbp	::=	frame-base-pointer-register?

dispoffset	::=	dispoffset?

label	::=	label?

procedure
(block-pred-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the block-pred-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-block-pred-lang-v8 a) → any/c
a : block-pred-lang-v8?

Evaluates a block-pred-lang-v8 program to a value.

block-asm-lang-v8 : grammar?

p	::=	(module b ... b)

b	::=	(define label tail)

tail	::=	(jump trg)
	\|	(begin s ... tail)
	\|	(if (relop loc opand) (jump trg) (jump trg))

s	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc index triv)

triv	::=	opand
	\|	label

opand	::=	int64
	\|	loc

trg	::=	label
	\|	loc

loc	::=	reg
	\|	addr

index	::=	int64
	\|	loc

reg	::=	rsp
	\|	rbp
	\|	rax
	\|	rbx
	\|	rcx
	\|	rdx
	\|	rsi
	\|	rdi
	\|	r8
	\|	r9
	\|	r12
	\|	r13
	\|	r14
	\|	r15

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

addr	::=	(fbp - dispoffset)

fbp	::=	frame-base-pointer-register?

dispoffset	::=	dispoffset?

label	::=	label?

procedure
(block-asm-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the block-asm-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-block-asm-lang-v8 a) → any/c
a : block-asm-lang-v8?

Evaluates a block-asm-lang-v8 program to a value.

para-asm-lang-v8 : grammar?

p	::=	(begin s ...)

s	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))
	\|	(set! loc_1 (mref loc_2 index))
	\|	(mset! loc_1 index triv)
	\|	(with-label label s)
	\|	(jump trg)
	\|	(compare loc opand)
	\|	(jump-if relop trg)

trg	::=	label
	\|	loc

triv	::=	opand
	\|	label

opand	::=	int64
	\|	loc

loc	::=	reg
	\|	addr

index	::=	int64
	\|	loc

reg	::=	rsp
	\|	rbp
	\|	rax
	\|	rbx
	\|	rcx
	\|	rdx
	\|	rsi
	\|	rdi
	\|	r8
	\|	r9
	\|	r12
	\|	r13
	\|	r14
	\|	r15

addr	::=	(fbp - dispoffset)

fbp	::=	frame-base-pointer-register?

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

label	::=	label?

dispoffset	::=	dispoffset?

procedure
(para-asm-lang-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the para-asm-lang-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-para-asm-lang-v8 a) → any/c
a : para-asm-lang-v8?

Evaluates a para-asm-lang-v8 program to a value.

paren-x64-mops-v8 : grammar?

p	::=	(begin s ...)

s	::=	(set! addr int32)
	\|	(set! addr trg)
	\|	(set! reg loc)
	\|	(set! reg triv)
	\|	(set! reg_1 (binop reg_1 int32))
	\|	(set! reg_1 (binop reg_1 loc))
	\|	(set! reg_1 (mref reg_2 index))
	\|	(mset! reg_1 index int32)
	\|	(mset! reg_1 index trg)
	\|	(with-label label s)
	\|	(jump trg)
	\|	(compare reg opand)
	\|	(jump-if relop label)

trg	::=	reg
	\|	label

triv	::=	trg
	\|	int64

opand	::=	int64
	\|	reg

loc	::=	reg
	\|	addr

index	::=	int32
	\|	reg

reg	::=	rsp
	\|	rbp
	\|	rax
	\|	rbx
	\|	rcx
	\|	rdx
	\|	rsi
	\|	rdi
	\|	r8
	\|	r9
	\|	r10
	\|	r11
	\|	r12
	\|	r13
	\|	r14
	\|	r15

addr	::=	(fbp - dispoffset)

fbp	::=	frame-base-pointer-register?

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

label	::=	label?

dispoffset	::=	dispoffset?

procedure
(paren-x64-mops-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the paren-x64-mops-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-paren-x64-mops-v8 a) → any/c
a : paren-x64-mops-v8?

Evaluates a paren-x64-mops-v8 program to a value.

paren-x64-v8 : grammar?

p	::=	(begin s ...)

s	::=	(set! addr int32)
	\|	(set! addr trg)
	\|	(set! reg loc)
	\|	(set! reg triv)
	\|	(set! reg_1 (binop reg_1 int32))
	\|	(set! reg_1 (binop reg_1 loc))
	\|	(with-label label s)
	\|	(jump trg)
	\|	(compare reg opand)
	\|	(jump-if relop label)

trg	::=	reg
	\|	label

triv	::=	trg
	\|	int64

opand	::=	int64
	\|	reg

loc	::=	reg
	\|	addr

reg	::=	rsp
	\|	rbp
	\|	rax
	\|	rbx
	\|	rcx
	\|	rdx
	\|	rsi
	\|	rdi
	\|	r8
	\|	r9
	\|	r10
	\|	r11
	\|	r12
	\|	r13
	\|	r14
	\|	r15

addr	::=	(fbp - dispoffset)
	\|	(reg + int32)
	\|	(reg + reg)

fbp	::=	frame-base-pointer-register?

binop	::=	*
	\|	+
	\|	-
	\|	bitwise-and
	\|	bitwise-ior
	\|	bitwise-xor
	\|	arithmetic-shift-right

relop	::=	<
	\|	<=
	\|	=
	\|	>=
	\|	>
	\|	!=

int64	::=	int64?

int32	::=	int32?

dispoffset	::=	dispoffset?

label	::=	label?

procedure
(paren-x64-v8? a) → boolean?
a : any/c

Decides whether a is a valid program in the paren-x64-v8 grammar, represented as a quoted datum. The first non-terminal in the grammar defines valid programs.

procedure
(interp-paren-x64-v8 a) → any/c
a : paren-x64-v8?

Evaluates a paren-x64-v8 program to a value.

1	Book
2	Project Milestones
3	CPSC 411 Infrastructure Package
4	Credits

3.1	Language Reference Implementations
3.2	Compiler Support
3.3	2c Run-Time System
3.4	Ptr Run-Time System
3.5	Info Data Structure
3.6	Functional Graphs
3.7	Testing

3.1.1	v1 Languages
3.1.2	v2 Languages
3.1.3	v2 Register Allocation Languages
3.1.4	v3 Languages
3.1.5	v4 Languages
3.1.6	v5 Languages
3.1.7	v6 Languages
3.1.8	v6.5 Languages
3.1.9	v7 Languages
3.1.10	v8 Languages
3.1.11	v9 Languages
3.1.12	v10 Languages
3.1.13	v11 Languages