From fa5590a452cfae4c32e48f68ff6c17d98d3b6d78 Mon Sep 17 00:00:00 2001 From: dtc <dtc> Date: Wed, 3 Jan 2001 08:45:23 +0000 Subject: [PATCH] From Raymond Toy: o Update trap instruction for the Sparc V9 trap instruction. o Change the order of the arguments to the branch instructions. so the prediction state comes before the condition code register. --- compiler/sparc/insts.lisp | 61 +++++++++++++++++++++++++++++++++------ 1 file changed, 52 insertions(+), 9 deletions(-) diff --git a/compiler/sparc/insts.lisp b/compiler/sparc/insts.lisp index d7c736ec9..bb7892c6f 100644 --- a/compiler/sparc/insts.lisp +++ b/compiler/sparc/insts.lisp @@ -5,7 +5,7 @@ ;;; Carnegie Mellon University, and has been placed in the public domain. ;;; (ext:file-comment - "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/sparc/insts.lisp,v 1.28 2000/12/05 03:06:53 dtc Exp $") + "$Header: /Volumes/share2/src/cmucl/cvs2git/cvsroot/src/compiler/sparc/insts.lisp,v 1.29 2001/01/03 08:45:23 dtc Exp $") ;;; ;;; ********************************************************************** ;;; @@ -223,11 +223,14 @@ ;; Currently only %icc and %xcc are used of the four possible values (defconstant integer-condition-registers - '(:icc :invalid-1 :xcc :invalid-2)) + '(:icc :reserved :xcc :reserved)) (defconstant integer-cond-reg-name-vec (coerce integer-condition-registers 'vector)) +(deftype integer-condition-register () + `(member ,@(remove :reserved integer-condition-registers))) + (defparameter integer-condition-reg-symbols (map 'vector #'(lambda (name) @@ -557,6 +560,20 @@ (rcond :field (byte 3 10) :type 'register-condition) (immed :field (byte 10 0) :sign-extend t)) +(defconstant trap-printer + `(:name rd :tab cc ", " immed)) + +(disassem:define-instruction-format + (format-4-trap 32 :default-printer trap-printer) + (op :field (byte 2 30)) + (rd :field (byte 5 25) :type 'reg) + (op3 :field (byte 6 19)) + (rs1 :field (byte 5 14) :type 'reg) + (i :field (byte 1 13) :value 1) + (cc :field (byte 2 11) :type 'integer-condition-register) + (immed :field (byte 11 0) :sign-extend t)) ; usually sign extended + + (defconstant cond-fp-move-integer-printer `(:name opf1 :tab rs1 ", " rs2 ", " rd)) @@ -627,6 +644,10 @@ (byte 2 30) (byte 5 25) (byte 6 19) (byte 5 14) (byte 1 13) (byte 3 10) (byte 10 0)) +(define-emitter emit-format-4-trap 32 + (byte 2 30) (byte 5 25) (byte 6 19) (byte 5 14) (byte 1 13) (byte 2 11) + (byte 11 0)) + ;;;; Most of the format-3-instructions. @@ -1063,6 +1084,7 @@ #+sparc-v9 (defun emit-relative-branch-integer (segment a op2 cond-or-target target &optional (cc :icc) (pred :pt)) + (declare (type integer-condition-register cc)) (emit-back-patch segment 4 #'(lambda (segment posn) (unless target @@ -1080,7 +1102,7 @@ offset))))) #+sparc-v9 -(defun emit-relative-branch-fp (segment a op2 cond-or-target target &optional (cc :icc) (pred :pt)) +(defun emit-relative-branch-fp (segment a op2 cond-or-target target &optional (cc :fcc0) (pred :pt)) (emit-back-patch segment 4 #'(lambda (segment posn) (unless target @@ -1114,7 +1136,7 @@ (emit-relative-branch segment 0 #b010 cond-or-target target))) #+sparc-v9 -(define-instruction b (segment cond-or-target &optional target cc pred) +(define-instruction b (segment cond-or-target &optional target pred cc) (:declare (type (or label branch-condition) cond-or-target) (type (or label null) target)) (:printer format-2-branch-pred ((op #b00) (op2 #b001)) @@ -1140,7 +1162,7 @@ (emit-relative-branch segment 1 #b010 cond-or-target target))) #+sparc-v9 -(define-instruction ba (segment cond-or-target &optional target cc pred) +(define-instruction ba (segment cond-or-target &optional target pred cc) (:declare (type (or label branch-condition) cond-or-target) (type (or label null) target)) (:printer format-2-branch ((op #b00) (op2 #b001) (a 1)) @@ -1154,10 +1176,11 @@ ;; This doesn't cover all of the possible formats for the trap ;; instruction. We really only want a trap with a immediate trap -;; value. Also, the Sparc Compliance Definition 2.4.1 says only trap -;; numbers 16-31 are allowed for user code. All other trap numbers -;; have other uses. The restriction on target will prevent us from -;; using bad trap numbers by mistake. +;; value and with RS1 = register 0. Also, the Sparc Compliance +;; Definition 2.4.1 says only trap numbers 16-31 are allowed for user +;; code. All other trap numbers have other uses. The restriction on +;; target will prevent us from using bad trap numbers by mistake. +#-sparc-v9 (define-instruction t (segment condition target) (:declare (type branch-condition condition) (type (integer 16 31) target)) @@ -1172,6 +1195,26 @@ (:emitter (emit-format-3-immed segment #b10 (branch-condition condition) #b111010 0 1 target))) +#+sparc-v9 +(define-instruction t (segment condition target &optional (cc #-sparc-64 :icc #+sparc-64 :xcc)) + (:declare (type branch-condition condition) + (type (integer 16 31) target) + (type integer-condition-register cc)) + (:printer format-4-trap ((op #b10) + (rd nil :type 'branch-condition) + (op3 #b111010) + (rs1 0)) + trap-printer) + (:attributes branch) + (:dependencies (reads :psr)) + (:delay 0) + (:emitter (emit-format-4-trap segment + #b10 + (branch-condition condition) + #b111010 0 1 + (integer-condition cc) + target))) + ;; Same as for the branch instructions. On the Sparc V9, we will use ;; the FP branch with prediction instructions instead. #-sparc-v9 -- GitLab