On this page:
values-lang-v6
values-lang-v6?
interp-values-lang-v6
values-unique-lang-v6
values-unique-lang-v6?
interp-values-unique-lang-v6
imp-mf-lang-v6
imp-mf-lang-v6?
interp-imp-mf-lang-v6
proc-imp-cmf-lang-v6
proc-imp-cmf-lang-v6?
interp-proc-imp-cmf-lang-v6
imp-cmf-lang-v6
imp-cmf-lang-v6?
interp-imp-cmf-lang-v6
asm-pred-lang-v6
asm-pred-lang-v6?
interp-asm-pred-lang-v6
asm-pred-lang-v6/  locals
asm-pred-lang-v6/  locals?
interp-asm-pred-lang-v6/  locals
asm-pred-lang-v6/  undead
asm-pred-lang-v6/  undead?
interp-asm-pred-lang-v6/  undead
asm-pred-lang-v6/  conflicts
asm-pred-lang-v6/  conflicts?
interp-asm-pred-lang-v6/  conflicts
asm-pred-lang-v6/  pre-framed
asm-pred-lang-v6/  pre-framed?
interp-asm-pred-lang-v6/  pre-framed
asm-pred-lang-v6/  framed
asm-pred-lang-v6/  framed?
interp-asm-pred-lang-v6/  framed
asm-pred-lang-v6/  spilled
asm-pred-lang-v6/  spilled?
interp-asm-pred-lang-v6/  spilled
asm-pred-lang-v6/  assignments
asm-pred-lang-v6/  assignments?
interp-asm-pred-lang-v6/  assignments
nested-asm-lang-fvars-v6
nested-asm-lang-fvars-v6?
interp-nested-asm-lang-fvars-v6
nested-asm-lang-v6
nested-asm-lang-v6?
interp-nested-asm-lang-v6
block-pred-lang-v6
block-pred-lang-v6?
interp-block-pred-lang-v6
block-asm-lang-v6
block-asm-lang-v6?
interp-block-asm-lang-v6
para-asm-lang-v6
para-asm-lang-v6?
interp-para-asm-lang-v6
paren-x64-v6
paren-x64-v6?
interp-paren-x64-v6
paren-x64-rt-v6
paren-x64-rt-v6?
interp-paren-x64-rt-v6
8.10
3.1.7 v6 Languages

 (require cpsc411/langs/v6) package: cpsc411-lib

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.
  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.
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.
  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.
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.
  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.
Evaluates a asm-pred-lang-v6/locals program to a value.
  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.
Evaluates a asm-pred-lang-v6/undead program to a value.
  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.
Evaluates a asm-pred-lang-v6/conflicts program to a value.
  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.
Evaluates a asm-pred-lang-v6/pre-framed program to a value.
  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.
Evaluates a asm-pred-lang-v6/framed program to a value.
  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.
Evaluates a asm-pred-lang-v6/spilled program to a value.
  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.
Evaluates a asm-pred-lang-v6/assignments program to a value.
  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.
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.
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.
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.
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.