-;;;; Low-level tests of the RTL assembler -*- mode: scheme; coding: utf-8; -*-
+;;;; Low-level tests of the bytecode assembler -*- mode: scheme; coding: utf-8; -*-
;;;;
-;;;; Copyright (C) 2010, 2011, 2012, 2013 Free Software Foundation, Inc.
+;;;; Copyright (C) 2010, 2011, 2012, 2013, 2014 Free Software Foundation, Inc.
;;;;
;;;; This library is free software; you can redistribute it and/or
;;;; modify it under the terms of the GNU Lesser General Public
;;;; License along with this library; if not, write to the Free Software
;;;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
-(define-module (tests rtl)
+(define-module (tests bytecode)
#:use-module (test-suite lib)
#:use-module (system vm assembler)
#:use-module (system vm program)
+ #:use-module (system vm loader)
+ #:use-module (system vm linker)
#:use-module (system vm debug))
+(define (assemble-program instructions)
+ "Take the sequence of instructions @var{instructions}, assemble them
+into bytecode, link an image, and load that image from memory. Returns
+a procedure."
+ (let ((asm (make-assembler)))
+ (emit-text asm instructions)
+ (load-thunk-from-memory (link-assembly asm #:page-aligned? #f))))
+
(define-syntax-rule (assert-equal val expr)
(let ((x val))
(pass-if (object->string x) (equal? expr x))))
'(1 2 3 4)
#(1 2 3)
#("foo" "bar" 'baz)
- ;; FIXME: Add tests for arrays (uniform and otherwise)
+ #vu8()
+ #vu8(1 2 3 4 128 129 130)
+ #u32()
+ #u32(1 2 3 4 128 129 130 255 1000)
+ ;; FIXME: Add more tests for arrays (uniform and otherwise)
))
(with-test-prefix "static procedure"
'((begin-program countdown
((name . countdown)))
(begin-standard-arity (x) 4 #f)
+ (definition x 1)
(br fix-body)
(label loop-head)
- (br-if-= 2 1 out)
+ (br-if-= 2 1 #f out)
(add 3 2 3)
(add1 2 2)
(br loop-head)
(begin-program accum
((name . accum)))
(begin-standard-arity (x) 4 #f)
+ (definition x 1)
(free-ref 2 0 0)
(box-ref 3 2)
(add 3 3 1)
(assemble-program
'((begin-program call
((name . call)))
- (begin-standard-arity (f) 2 #f)
- (push-frame 2 1)
+ (begin-standard-arity (f) 7 #f)
+ (definition f 1)
(mov 5 1)
- (call 2)
- (return 2) ;; MVRA from call
- (return 2) ;; RA from call
+ (call 5 1)
+ (receive 2 5 7)
+ (return 2)
(end-arity)
(end-program)))))
(call (lambda () 42))))
(assemble-program
'((begin-program call-with-3
((name . call-with-3)))
- (begin-standard-arity (f) 3 #f)
- (push-frame 2 2)
+ (begin-standard-arity (f) 7 #f)
+ (definition f 1)
(mov 5 1)
(load-constant 6 3)
- (call 2)
- (return 2) ;; MVRA from call
- (return 2) ;; RA from call
+ (call 5 2)
+ (receive 2 5 7)
+ (return 2)
(end-arity)
(end-program)))))
(call-with-3 (lambda (x) (* x 2))))))
'((begin-program call
((name . call)))
(begin-standard-arity (f) 2 #f)
- (tail-call 0 1)
+ (definition f 1)
+ (mov 0 1)
+ (tail-call 1)
(end-arity)
(end-program)))))
(call (lambda () 3))))
(assemble-program
'((begin-program call-with-3
((name . call-with-3)))
- (begin-standard-arity (f) 3 #f)
- (mov 2 1) ;; R1 <- R0
- (load-constant 1 3) ;; R0 <- 3
- (tail-call 1 2)
+ (begin-standard-arity (f) 2 #f)
+ (definition f 1)
+ (mov 0 1) ;; R0 <- R1
+ (load-constant 1 3) ;; R1 <- 3
+ (tail-call 2)
(end-arity)
(end-program)))))
(call-with-3 (lambda (x) (* x 2))))))
'((begin-program get-sqrt-trampoline
((name . get-sqrt-trampoline)))
(begin-standard-arity () 2 #f)
+ (current-module 1)
(cache-current-module! 1 sqrt-scope)
(load-static-procedure 1 sqrt-trampoline)
(return 1)
(begin-program sqrt-trampoline
((name . sqrt-trampoline)))
(begin-standard-arity (x) 3 #f)
- (cached-toplevel-ref 2 sqrt-scope sqrt)
- (tail-call 1 2)
+ (definition x 1)
+ (cached-toplevel-box 2 sqrt-scope sqrt #t)
+ (box-ref 0 2)
+ (tail-call 2)
(end-arity)
(end-program)))))
((get-sqrt-trampoline) 25.0))))
'((begin-program make-top-incrementor
((name . make-top-incrementor)))
(begin-standard-arity () 2 #f)
+ (current-module 1)
(cache-current-module! 1 top-incrementor)
(load-static-procedure 1 top-incrementor)
(return 1)
(begin-program top-incrementor
((name . top-incrementor)))
- (begin-standard-arity () 2 #f)
- (cached-toplevel-ref 1 top-incrementor *top-val*)
- (add1 1 1)
- (cached-toplevel-set! 1 top-incrementor *top-val*)
- (return/values 1)
+ (begin-standard-arity () 3 #f)
+ (cached-toplevel-box 1 top-incrementor *top-val* #t)
+ (box-ref 2 1)
+ (add1 2 2)
+ (box-set! 1 2)
+ (reset-frame 1)
+ (return-values)
(end-arity)
(end-program)))))
((make-top-incrementor))
(begin-program sqrt-trampoline
((name . sqrt-trampoline)))
(begin-standard-arity (x) 3 #f)
- (cached-module-ref 2 (guile) #t sqrt)
- (tail-call 1 2)
+ (definition x 1)
+ (cached-module-box 2 (guile) sqrt #t #t)
+ (box-ref 0 2)
+ (tail-call 2)
(end-arity)
(end-program)))))
((get-sqrt-trampoline) 25.0))))
(begin-program top-incrementor
((name . top-incrementor)))
- (begin-standard-arity () 2 #f)
- (cached-module-ref 1 (tests rtl) #f *top-val*)
- (add1 1 1)
- (cached-module-set! 1 (tests rtl) #f *top-val*)
- (return 1)
+ (begin-standard-arity () 3 #f)
+ (cached-module-box 1 (tests bytecode) *top-val* #f #t)
+ (box-ref 2 1)
+ (add1 2 2)
+ (box-set! 1 2)
+ (return 2)
(end-arity)
(end-program)))))
((make-top-incrementor))
(end-arity)
(end-program)))))
(pass-if "program name"
- (and=> (find-program-debug-info (rtl-program-code return-3))
+ (and=> (find-program-debug-info (program-code return-3))
(lambda (pdi)
(equal? (program-debug-info-name pdi)
'return-3))))
(pass-if "program address"
- (and=> (find-program-debug-info (rtl-program-code return-3))
+ (and=> (find-program-debug-info (program-code return-3))
(lambda (pdi)
(equal? (program-debug-info-addr pdi)
- (rtl-program-code return-3)))))))
+ (program-code return-3)))))))
(with-test-prefix "procedure name"
(pass-if-equal 'foo
(end-arity)
(end-program))))))
-(with-test-prefix "simply procedure arity"
+(with-test-prefix "simple procedure arity"
(pass-if-equal "#<procedure foo ()>"
(object->string
(assemble-program
(assemble-program
'((begin-program foo ((name . foo)))
(begin-standard-arity (x y) 3 #f)
+ (definition x 1)
+ (definition y 2)
(load-constant 1 42)
(return 1)
(end-arity)
(assemble-program
'((begin-program foo ((name . foo)))
(begin-opt-arity (x) (y) z 4 #f)
+ (definition x 1)
+ (definition y 2)
+ (definition z 3)
(load-constant 1 42)
(return 1)
(end-arity)