From a9917a3cd5158d8fc9179fb252dd0f596ecfcf65 Mon Sep 17 00:00:00 2001
From: "Guillermo J. Rozas" <edu/mit/csail/zurich/gjr>
Date: Sun, 9 Feb 1992 00:26:28 +0000
Subject: [PATCH] More changes.

---
 v7/src/compiler/machines/i386/instr1.scm | 213 +++++++++++++++++++----
 1 file changed, 178 insertions(+), 35 deletions(-)

diff --git a/v7/src/compiler/machines/i386/instr1.scm b/v7/src/compiler/machines/i386/instr1.scm
index e2066a7d1..3d2af7f49 100644
--- a/v7/src/compiler/machines/i386/instr1.scm
+++ b/v7/src/compiler/machines/i386/instr1.scm
@@ -1,6 +1,6 @@
 #| -*-Scheme-*-
 
-$Header: /Users/cph/tmp/foo/mit-scheme/mit-scheme/v7/src/compiler/machines/i386/instr1.scm,v 1.1 1992/02/08 18:15:41 jinx Exp $
+$Header: /Users/cph/tmp/foo/mit-scheme/mit-scheme/v7/src/compiler/machines/i386/instr1.scm,v 1.2 1992/02/09 00:26:28 jinx Exp $
 
 Copyright (c) 1992 Massachusetts Institute of Technology
 
@@ -32,22 +32,22 @@ Technology nor of any adaptation thereof in any advertising,
 promotional, or sales literature without prior written consent from
 MIT in each case. |#
 
-;;;; Intel 386 Instruction Set, part I
+;;;; Intel i386 Instruction Set, part I
+
+;; Some of the instructions have their operands ill-specified in the
+;; i486 book.  Check against the appendices or the i386 book.
 
 (declare (usual-integrations))
 
 ;; Utility
 
-(define-macro (define-trivial-instruction mnemonic opcode)
-  `(define-instruction ,mnemonic
-     (()
-      (BYTE (8 ,opcode)))))
-
-(define-macro (define-trivial-instruction/2 mnemonic escape opcode)
+(define-macro (define-trivial-instruction mnemonic opcode . extra)
   `(define-instruction ,mnemonic
      (()
-      (BYTE (8 ,escape)
-	    (8 ,opcode)))))
+      (BYTE (8 ,opcode))
+      ,@(map (lambda (extra)
+	       `(BYTE (8 ,extra)))
+	     extra))))
 
 ;;;; Pseudo ops
 
@@ -71,53 +71,53 @@ MIT in each case. |#
 
 ;;;; Actual instructions
 
-(define-trivial-instruction   AAA #x37)
-(define-trivial-instruction/2 AAD #xd5 #x0a)
-(define-trivial-instruction/2 AAM #xd4 #x0a)
-(define-trivial-instruction   AAS #x3f)
+(define-trivial-instruction AAA #x37)
+(define-trivial-instruction AAD #xd5 #x0a)
+(define-trivial-instruction AAM #xd4 #x0a)
+(define-trivial-instruction AAS #x3f)
 
 (let-syntax
     ((define-arithmetic-instruction
        (macro (mnemonic opcode digit)
-	 `(define-instruction ADC
-	    ((B (R 0) (& (? value)))
-	     (BYTE (8 ,(+ opcode 4))
-		   (8 value SIGNED)))
-
-	    ((W (R 0) (& (? value)))
-	     (BYTE (8 ,(+ opcode 5)))
-	     (IMMEDIATE value SIGNED))
+	 `(define-instruction ,mnemonic
+	    ((W (? target r/mW) (R (? source)))
+	     (BYTE (8 ,(1+ opcode)))
+	     (ModR/M source target))
 
-	    ((B (? target r/m8) (& (? value)))
-	     (BYTE (8 #x80))
-	     (ModR/M ,digit target)
-	     (BYTE (8 value SIGNED)))
+	    ((W (R (? target)) (? source r/mW))
+	     (BYTE (8 ,(+ opcode 3)))
+	     (ModR/M target source))
 
 	    ((W (? target r/mW) (& (? value full-word-value)))
 	     (BYTE (8 #x81))
 	     (ModR/M ,digit target)
-	     (IMMEDIATE value SIGNED))
+	     (IMMEDIATE value))
 
 	    ((W (? target r/mW) (& (? value sign-extensible-value)))
 	     (BYTE (8 #x83))
 	     (ModR/M ,digit target)
 	     (BYTE (value SIGNED)))
 
+	    ((W (R 0) (& (? value)))	; AX/EAX
+	     (BYTE (8 ,(+ opcode 5)))
+	     (IMMEDIATE value))
+
 	    ((B (? target r/m8) (R (? source)))
 	     (BYTE (8 ,opcode))
 	     (ModR/M source target))
 
-	    ((W (? target r/mW) (R (? source)))
-	     (BYTE (8 ,(1+ opcode)))
-	     (ModR/M source target))
-
 	    ((B (R (? target)) (? source r/m8))
 	     (BYTE (8 ,(+ opcode 2)))
 	     (ModR/M target source))
 
-	    ((W (R (? target)) (? source r/mW))
-	     (BYTE (8 ,(+ opcode 3)))
-	     (ModR/M target source))))))
+	    ((B (R 0) (& (? value)))	; AL
+	     (BYTE (8 ,(+ opcode 4))
+		   (8 value SIGNED)))
+
+	    ((B (? target r/m8) (& (? value)))
+	     (BYTE (8 #x80))
+	     (ModR/M ,digit target)
+	     (BYTE (8 value SIGNED)))))))
 
   (define-arithmetic-instruction ADC #x10 2)
   (define-arithmetic-instruction ADD #x00 0)
@@ -126,4 +126,147 @@ MIT in each case. |#
   (define-arithmetic-instruction OR  #x08 1)
   (define-arithmetic-instruction SBB #x18 3)
   (define-arithmetic-instruction SUB #x28 5)
-  (define-arithmetic-instruction XOR #x30 6))
\ No newline at end of file
+  (define-arithmetic-instruction XOR #x30 6))
+
+(define-instruction ARPL
+  (((? target r/mW) (R (? source)))
+   (BYTE (8 #x63))
+   (ModR/M source target 16)))
+
+(define-instruction BOUND
+  (((R (? source)) (? bounds mW))
+   (BYTE (8 #x62))
+   (ModR/M source bounds)))
+
+(define-instruction BSF
+  (((R (? target)) (? source r/mW))
+   (BYTE (8 #x0f)
+	 (8 #xbc))
+   (ModR/M target source)))
+
+(define-instruction BSR
+  (((R (? target)) (? source r/mW))
+   (BYTE (8 #x0f)
+	 (8 #xbd))
+   (ModR/M target source)))
+
+(define-instruction BSWAP
+  ;; 486 only
+  (((R (? reg)))
+   (BYTE (8 #x0f)
+	 (8 (+ #xc8 reg)))))
+
+(let-syntax
+    ((define-bit-test-instruction
+       (macro (mnemonic opcode digit)
+	 `(define-instruction ,mnemonic
+	    (((? target r/mW) (& (? posn)))
+	     (BYTE (8 #x0f)
+		   (8 #xba))
+	     (ModR/M ,digit target)
+	     (BYTE (8 posn UNSIGNED)))
+
+	    (((? target r/mW) (R (? posn)))
+	     (BYTE (8 #x0f)
+		   (8 ,opcode))
+	     (ModR/M posn target))))))
+
+  (define-bit-test-instruction BT  #xa3 4)
+  (define-bit-test-instruction BTC #xbb 7)
+  (define-bit-test-instruction BTR #xb3 6)
+  (define-bit-test-instruction BTS #xab 5))
+  
+(define-instruction CALL
+  (((@PCR ,dest))
+   (BYTE (8 #xe8))
+   (IMMEDIATE `(- ,dest (+ *PC* 2)) ADDRESS))
+
+  (((@PCO ,dest))
+   (BYTE (8 #xe8))
+   (IMMEDIATE dest ADDRESS))
+
+  (((? dest r/mW))
+   (BYTE (8 #xff))
+   (ModR/M 2 dest))
+
+  ((I (? dest mW))
+   (BYTE (8 #xff))
+   (ModR/M 3 dest))
+
+  ((I (SEGMENT (? seg)) (OFFSET (? off)))
+   (BYTE (8 #x9a))
+   (BYTE (16 seg UNSIGNED))
+   (IMMEDIATE off ADDRESS)))
+
+(define-trivial-instruction CBW #x98)
+(define-trivial-instruction CWDE #x98)
+(define-trivial-instruction CLC #xf8)
+(define-trivial-instruction CLD #xfc)
+(define-trivial-instruction CLI #xfa)
+(define-trivial-instruction CLTS #x0f #x06)
+(define-trivial-instruction CMC #xf5)
+
+(define-instruction CMPS
+  ((W)
+   (BYTE (8 #xa7)))
+
+  ((B)
+   (BYTE (8 #xa6))))
+
+(define-instruction CMPXCHG
+  ((W (? target r/mW) (R (? reg)))
+   (BYTE (8 #x0f)
+	 (8 #xa7))
+   (ModR/M reg target))
+
+  ((B (? target r/m8) (R (? reg)))
+   (BYTE (8 #x0f)
+	 (8 #xa6))
+   (ModR/M reg target)))
+
+(define-trivial-instruction CWD #x99)
+(define-trivial-instruction CDQ #x99)
+(define-trivial-instruction DAA #x27)
+(define-trivial-instruction DAS #x2f)
+
+(let-syntax
+    ((define-inc/dec
+       (macro (mnemonic digit opcode)
+	 `(define-instruction ,mnemonic
+	    ((W (R (? reg)))
+	     (BYTE (8 (+ ,opcode reg))))
+
+	    ((W (? target r/mW))
+	     (BYTE (8 #xff))
+	     (ModR/M ,digit target))
+
+	    ((B (? target r/m8))
+	     (BYTE (8 #xfe))
+	     (ModR/M ,digit target))))))
+
+  (define-inc/dec DEC 1 #x48)
+  (define-inc/dec INC 0 #x40))
+
+(let-syntax
+    ((define-mul/div
+       (macro (mnemonic digit)
+	 `(define-instruction ,mnemonic
+	    ((W (R 0) (? operand r/mW))
+	     (BYTE (8 #xf7))
+	     (ModR/M digit operand))
+
+	    ((B (R 0) (? operand r/m8))
+	     (BYTE (8 #xf6))
+	     (ModR/M digit operand))))))
+
+  (define-mul/div DIV 6)
+  (define-mul/div IDIV 7)
+  (define-mul/div MUL 4))
+
+(define-instruction ENTER
+  (((& (? frame-size)) (& (? lexical-level)))
+   (BYTE (8 #xc8)
+	 (16 frame-size)
+	 (8 lexical-level))))
+
+(define-trivial-instruction HLT #xf4)
-- 
2.25.1