3.1.7 v6 Languages

values-lang-v6 : grammar?

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

pred	::=	(relop triv triv)
	\|	(true)
	\|	(false)
	\|	(not pred)
	\|	(let ([x value] ...) pred)
	\|	(if pred pred pred)

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

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

triv	::=	x
	\|	int64

x	::=	name?

binop	::=	*
	\|	+
	\|	-

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

int64	::=	int64?

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

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

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

Evaluates a values-lang-v6 program to a value.

values-unique-lang-v6 : 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)

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

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

opand	::=	aloc
	\|	int64

triv	::=	opand
	\|	label

binop	::=	*
	\|	+
	\|	-

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

aloc	::=	aloc?

label	::=	label?

int64	::=	int64?

procedure
(values-unique-lang-v6? a) → boolean?
a : any/c

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

procedure
(interp-values-unique-lang-v6 a) → any/c
a : values-unique-lang-v6?

Evaluates a values-unique-lang-v6 program to a value.

imp-mf-lang-v6 : 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)
	\|	(begin effect ... value)
	\|	(if pred value value)

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

opand	::=	aloc
	\|	int64

triv	::=	opand
	\|	label

binop	::=	*
	\|	+
	\|	-

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

aloc	::=	aloc?

label	::=	label?

int64	::=	int64?

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

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

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

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

proc-imp-cmf-lang-v6 : 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)

|

(call triv opand ...)

effect

::=

(set! aloc value)

|

(begin effect ...)

|

(if pred effect effect)

opand

::=

aloc

|

int64

triv

::=

opand

|

label

binop

::=

*

|

+

|

-

relop

::=

<

|

<=

|

=

|

>=

|

>

|

!=

aloc

::=

aloc?

label

::=

label?

int64

::=

int64?

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

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

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

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

imp-cmf-lang-v6 : 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)

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

opand	::=	loc
	\|	int64

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	loc
	\|	label

binop	::=	*
	\|	+
	\|	-

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

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

int64	::=	int64?

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

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

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

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

asm-pred-lang-v6 : 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))
	\|	(begin effect ...)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	loc
	\|	int64

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	loc
	\|	label

binop	::=	*
	\|	+
	\|	-

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

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

int64	::=	int64?

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

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

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

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

asm-pred-lang-v6/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))
	\|	(begin effect ...)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	loc
	\|	int64

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	loc
	\|	label

binop	::=	*
	\|	+
	\|	-

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

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

int64	::=	int64?

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

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

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

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

asm-pred-lang-v6/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))
	\|	(begin effect ...)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	loc
	\|	int64

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	loc
	\|	label

binop	::=	*
	\|	+
	\|	-

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

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

int64	::=	int64?

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

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

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

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

asm-pred-lang-v6/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))
	\|	(begin effect ...)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	loc
	\|	int64

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	loc
	\|	label

binop	::=	*
	\|	+
	\|	-

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

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

int64	::=	int64?

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

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

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

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

asm-pred-lang-v6/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 fvar) ...))))

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))
	\|	(begin effect ...)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	loc
	\|	int64

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	loc
	\|	label

binop	::=	*
	\|	+
	\|	-

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

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

fvar	::=	fvar?

int64	::=	int64?

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

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

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

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

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

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

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

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))
	\|	(begin effect ...)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	loc
	\|	int64

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	loc
	\|	label

binop	::=	*
	\|	+
	\|	-

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

int64	::=	int64?

aloc	::=	aloc?

label	::=	label?

fvar	::=	fvar?

rloc	::=	register?
	\|	fvar?

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

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

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

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

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

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

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

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))
	\|	(begin effect ...)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	loc
	\|	int64

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	loc
	\|	label

binop	::=	*
	\|	+
	\|	-

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

int64	::=	int64?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

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

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

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

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

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

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

info	::=	(#:from-contract (info/c (assignment ((aloc 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))
	\|	(begin effect ...)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	loc
	\|	int64

triv	::=	opand
	\|	label

loc	::=	rloc
	\|	aloc

trg	::=	loc
	\|	label

binop	::=	*
	\|	+
	\|	-

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

int64	::=	int64?

aloc	::=	aloc?

label	::=	label?

rloc	::=	register?
	\|	fvar?

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

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

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

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

nested-asm-lang-fvars-v6 : 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))
	\|	(begin effect ...)
	\|	(if pred effect effect)
	\|	(return-point label tail)

opand	::=	loc
	\|	int64

triv	::=	opand
	\|	label

loc	::=	reg
	\|	fvar

trg	::=	loc
	\|	label

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

binop	::=	*
	\|	+
	\|	-

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

int64	::=	int64?

fvar	::=	fvar?

label	::=	label?

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

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

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

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

nested-asm-lang-v6 : 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))
	\|	(begin effect ...)
	\|	(if pred effect effect)
	\|	(return-point label tail)

triv	::=	opand
	\|	label

opand	::=	loc
	\|	int64

trg	::=	loc
	\|	label

loc	::=	reg
	\|	addr

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

binop	::=	*
	\|	+
	\|	-

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

int64	::=	int64?

addr	::=	(fbp - dispoffset)

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

dispoffset	::=	dispoffset?

label	::=	label?

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

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

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

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

block-pred-lang-v6 : grammar?

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

b	::=	(define label tail)

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

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

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))

triv	::=	opand
	\|	label

opand	::=	loc
	\|	int64

trg	::=	loc
	\|	label

loc	::=	reg
	\|	addr

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

binop	::=	*
	\|	+
	\|	-

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

int64	::=	int64?

addr	::=	(fbp - dispoffset)

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

dispoffset	::=	dispoffset?

label	::=	label?

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

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

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

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

block-asm-lang-v6 : grammar?

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

b	::=	(define label tail)

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

effect	::=	(set! loc triv)
	\|	(set! loc_1 (binop loc_1 opand))

triv	::=	opand
	\|	label

opand	::=	loc
	\|	int64

trg	::=	loc
	\|	label

loc	::=	reg
	\|	addr

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

binop	::=	*
	\|	+
	\|	-

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

int64	::=	int64?

addr	::=	(fbp - dispoffset)

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

dispoffset	::=	dispoffset?

label	::=	label?

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

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

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

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

para-asm-lang-v6 : grammar?

p	::=	(begin s ...)

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

triv	::=	opand
	\|	label

opand	::=	loc
	\|	int64

trg	::=	loc
	\|	label

loc	::=	reg
	\|	addr

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

binop	::=	*
	\|	+
	\|	-

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

addr	::=	(fbp - dispoffset)

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

int64	::=	int64?

dispoffset	::=	dispoffset?

label	::=	label?

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

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

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

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

paren-x64-v6 : 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	::=	reg
	\|	int64

loc	::=	reg
	\|	addr

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	::=	*
	\|	+
	\|	-

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

int64	::=	int64?

int32	::=	int32?

dispoffset	::=	dispoffset?

label	::=	label?

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

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

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

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

paren-x64-rt-v6 : grammar?

p	::=	(begin s ...)

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

trg	::=	reg
	\|	pc-addr

triv	::=	trg
	\|	int64

opand	::=	reg
	\|	int64

loc	::=	reg
	\|	addr

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	::=	*
	\|	+
	\|	-

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

int64	::=	int64?

int32	::=	int32?

dispoffset	::=	dispoffset?

label	::=	label?

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

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

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

Evaluates a paren-x64-rt-v6 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