(include-book "m5/m5")
(in-package "M5")

; The following M5 bytecode implements the method g in Demo2.java:
#|
class Demo2 {
    public static int g(int x, int y){
	if (x<y) {return 0;}
	else return 1+g(x-y,y);
  }

  public static void main(String[] args){
      int x = Integer.parseInt(args[0], 10);
      int y = Integer.parseInt(args[1], 10);
      System.out.println(g(x,y));
      return;
    }
}
|#
; except that since M5 does not have IF_CMPGE I have to use
; a comparison against 0 (IFLT).

(defconst *s*
  (make state
        :tt (list (make thread
                        :id 0
                        :cs (push (make frame
                                        :pc     0
                                        :locs   nil
                                        :stk    nil
                                        :mloc   '("Demo2" "main" 1))
                                  nil)
                        :stat 'active
                        :ref  nil))
        :hp nil
        :ct (append *base-classes*
                    (list (make class
                                :name "Demo2"
                                :supers '("Object")
                                :fields nil
                                :methods (list (make method
                                                     :name "g"
                                                     :formals '(x y)
                                                     :sync nil
                                                     :code '((LOAD 0)  ;  0
                                                             (LOAD 1)  ;  1
                                                             (SUB)     ;  2
                                                             (IFLT 9)  ;  3
                                                             (CONST 1) ;  4
                                                             (LOAD 0)  ;  5
                                                             (LOAD 1)  ;  6
                                                             (SUB)     ;  7
                                                             (LOAD 1)  ;  8
                                                             (INVOKESTATIC ("Demo2" "g" 2))
                                                             (ADD)     ; 10
                                                             (XRETURN) ; 11
                                                             (CONST 0) ; 12
                                                             (XRETURN)); 13
                                                     :xtbl nil)
                                                (make method
                                                      :name "main"
                                                      :formals nil
                                                      :sync nil
                                                      :code '((CONST 33)
                                                              (CONST 5)
                                                              (INVOKESTATIC ("Demo2" "g" 2))
                                                              (XRETURN))
                                                      :xtbl nil)))))))

; The following expressions snapshot a complete execution of state *s*.

(run (repeat 0 2) *s*)
(next-inst 0 (run (repeat 0 2) *s*))

; To avoid seeing the large and unchaning part of the state, I will use this
; expression instead: run the state n=2 steps and then show me thread 0 and the
; next instruction of thread 0.  But I'll use various values of n to select
; ``interesting'' intermediate states.

(let ((s (run (repeat 0 2) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 3) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 13) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 23) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 33) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 43) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 53) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 63) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 66) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 67) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 68) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 69) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 70) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 71) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 72) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 73) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 79) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 80) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 81) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

(let ((s (run (repeat 0 82) *s*)))
  (list (find :id 0 (tt s)) (next-inst 0 s)))

; Here are the M5 semantics of INVOKESTATIC and xRETURN:

(pe 'execute-INVOKESTATIC)
(pe 'resolve-method-name)
(pe 'method-locator)
(pe 'execute-XRETURN)
(pe 'execute-RETURN)