Add Jo, Jno, Jc, Jnc.

Author: dvanhorn

langs/a86/ast.rkt

@@ -137,6 +137,10 @@
 (instruct Jle    (x)       check:target)
 (instruct Jg     (x)       check:target)
 (instruct Jge    (x)       check:target)
+(instruct Jo     (x)       check:target)
+(instruct Jno    (x)       check:target)
+(instruct Jc     (x)       check:target)
+(instruct Jnc    (x)       check:target)
 (instruct And    (dst src) check:src-dest)
 (instruct Or     (dst src) check:src-dest)
 (instruct Xor    (dst src) check:src-dest)
@@ -201,6 +205,10 @@
       (Jle? x)
       (Jg? x)
       (Jge? x)
+      (Jo? x)
+      (Jno? x)
+      (Jc? x)
+      (Jnc? x)
       (And? x)
       (Or? x)
       (Xor? x)

langs/a86/printer.rkt

@@ -141,6 +141,18 @@
       [(Jge l)
        (string-append tab "jge "
                       (jump-target->string l))]
+      [(Jo l)
+       (string-append tab "jo "
+                      (jump-target->string l))]
+      [(Jno l)
+       (string-append tab "jno "
+                      (jump-target->string l))]
+      [(Jc l)
+       (string-append tab "jc "
+                      (jump-target->string l))]
+      [(Jnc l)
+       (string-append tab "jnc "
+                      (jump-target->string l))]
       [(Call l)
        (string-append tab "call "
                       (jump-target->string l))]

www/notes/a86.scrbl

@@ -1028,6 +1028,75 @@ Each register plays the same role as in x86, so for example
  ]
 }
 
+@defstruct*[Jo ([x (or/c label? register?)])]{
+ Jump to @racket[x] if the overflow flag is set.
+
+ @ex[
+ (asm-interp
+  (prog
+   (Global 'entry)
+   (Label 'entry)
+   (Mov 'rax (sub1 (expt 2 63)))
+   (Add 'rax 1)
+   (Jo 'l1)
+   (Mov 'rax 0)
+   (Label 'l1)
+   (Ret)))
+ ]
+}
+
+@defstruct*[Jno ([x (or/c label? register?)])]{
+ Jump to @racket[x] if the overflow flag is @emph{not} set.
+
+ @ex[
+ (asm-interp
+  (prog
+   (Global 'entry)
+   (Label 'entry)
+   (Mov 'rax (sub1 (expt 2 63)))
+   (Add 'rax 1)
+   (Jno 'l1)
+   (Mov 'rax 0)
+   (Label 'l1)
+   (Ret)))
+ ]
+}
+
+@defstruct*[Jc ([x (or/c label? register?)])]{
+ Jump to @racket[x] if the carry flag is set.
+
+ @ex[
+ (asm-interp
+  (prog
+   (Global 'entry)
+   (Label 'entry)
+   (Mov 'rax -1)
+   (Add 'rax 1)
+   (Jc 'l1)
+   (Mov 'rax 0)
+   (Label 'l1)
+   (Ret)))
+ ]
+}
+
+@defstruct*[Jnc ([x (or/c label? register?)])]{
+ Jump to @racket[x] if the carry flag is @emph{not} set.
+
+ @ex[
+ (asm-interp
+  (prog
+   (Global 'entry)
+   (Label 'entry)
+   (Mov 'rax -1)
+   (Add 'rax 1)
+   (Jnc 'l1)
+   (Mov 'rax 0)
+   (Label 'l1)
+   (Ret)))
+ ]
+}
+
+
 @defstruct*[And ([dst (or/c register? offset?)] [src (or/c register? offset? exact-integer?)])]{
  Compute logical ``and'' of @racket[dst] and @racket[src] and put result in @racket[dst].