X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;ds=inline;f=src%2Fcompiler%2Falpha%2Fmove.lisp;h=3367260c5bf08d80e616b0a6853bfd809b1e910f;hb=4a0ab5193096ca70dbbf43bb21418544f6d018b7;hp=e9901e7951a5994e9c2fe1dc378e0a070419277a;hpb=dfa55a883f94470267b626dae77ce7e7dfac3df6;p=sbcl.git diff --git a/src/compiler/alpha/move.lisp b/src/compiler/alpha/move.lisp index e9901e7..3367260 100644 --- a/src/compiler/alpha/move.lisp +++ b/src/compiler/alpha/move.lisp @@ -1,22 +1,15 @@ -;;; -*- Package: ALPHA -*- -;;; -;;; ********************************************************************** -;;; This code was written as part of the CMU Common Lisp project at -;;; Carnegie Mellon University, and has been placed in the public domain. -;;; - -;;; -;;; ********************************************************************** -;;; -;;; This file contains the MIPS VM definition of operand loading/saving and -;;; the Move VOP. -;;; -;;; Written by Rob MacLachlan. -;;; Conversion by Sean Hallgren. -;;; -(in-package "SB!VM") +;;;; the Alpha VM definition of operand loading/saving and the Move VOP +;;;; This software is part of the SBCL system. See the README file for +;;;; more information. +;;;; +;;;; This software is derived from the CMU CL system, which was +;;;; written at Carnegie Mellon University and released into the +;;;; public domain. The software is in the public domain and is +;;;; provided with absolutely no warranty. See the COPYING and CREDITS +;;;; files for more information. +(in-package "SB!VM") (define-move-function (load-immediate 1) (vop x y) ((null zero immediate) @@ -81,10 +74,9 @@ (unsigned-reg) (unsigned-stack)) (let ((nfp (current-nfp-tn vop))) (storeq x nfp (tn-offset y)))) - -;;;; The Move VOP: -;;; +;;;; The Move VOP + (define-vop (move) (:args (x :target y :scs (any-reg descriptor-reg zero null) @@ -105,15 +97,13 @@ (any-reg descriptor-reg zero null) (any-reg descriptor-reg)) -;;; Make Move the check VOP for T so that type check generation doesn't think -;;; it is a hairy type. This also allows checking of a few of the values in a -;;; continuation to fall out. -;;; +;;; Make Move the check VOP for T so that type check generation +;;; doesn't think it is a hairy type. This also allows checking of a +;;; few of the values in a continuation to fall out. (primitive-type-vop move (:check) t) -;;; The Move-Argument VOP is used for moving descriptor values into another -;;; frame for argument or known value passing. -;;; +;;; The Move-Argument VOP is used for moving descriptor values into +;;; another frame for argument or known value passing. (define-vop (move-argument) (:args (x :target y :scs (any-reg descriptor-reg null zero)) @@ -130,16 +120,13 @@ (define-move-vop move-argument :move-argument (any-reg descriptor-reg null zero) (any-reg descriptor-reg)) - - ;;;; ILLEGAL-MOVE -;;; This VOP exists just to begin the lifetime of a TN that couldn't be written -;;; legally due to a type error. An error is signalled before this VOP is -;;; so we don't need to do anything (not that there would be anything sensible -;;; to do anyway.) -;;; +;;; This VOP exists just to begin the lifetime of a TN that couldn't +;;; be written legally due to a type error. An error is signalled +;;; before this VOP is so we don't need to do anything (not that there +;;; would be anything sensible to do anyway.) (define-vop (illegal-move) (:args (x) (type)) (:results (y)) @@ -148,18 +135,16 @@ (:save-p :compute-only) (:generator 666 (error-call vop object-not-type-error x type))) - - -;;;; Moves and coercions: - -;;; These MOVE-TO-WORD VOPs move a tagged integer to a raw full-word -;;; representation. Similarly, the MOVE-FROM-WORD VOPs converts a raw integer -;;; to a tagged bignum or fixnum. - -;;; Arg is a fixnum, so just shift it. We need a type restriction because some -;;; possible arg SCs (control-stack) overlap with possible bignum arg SCs. -;;; +;;;; moves and coercions +;;;; +;;;; These MOVE-TO-WORD VOPs move a tagged integer to a raw full-word +;;;; representation. Similarly, the MOVE-FROM-WORD VOPs converts a raw +;;;; integer to a tagged bignum or fixnum. + +;;; Arg is a fixnum, so just shift it. We need a type restriction +;;; because some possible arg SCs (control-stack) overlap with +;;; possible bignum arg SCs. (define-vop (move-to-word/fixnum) (:args (x :scs (any-reg descriptor-reg))) (:results (y :scs (signed-reg unsigned-reg))) @@ -213,9 +198,8 @@ (descriptor-reg) (signed-reg unsigned-reg)) -;;; Result is a fixnum, so we can just shift. We need the result type +;;; Result is a fixnum, so we can just shift. We need the result type ;;; restriction because of the control-stack ambiguity noted above. -;;; (define-vop (move-from-word/fixnum) (:args (x :scs (signed-reg unsigned-reg))) (:results (y :scs (any-reg descriptor-reg))) @@ -227,9 +211,8 @@ (define-move-vop move-from-word/fixnum :move (signed-reg unsigned-reg) (any-reg descriptor-reg)) -;;; Result may be a bignum, so we have to check. Use a worst-case cost to make -;;; sure people know they may be number consing. -;;; +;;; Result may be a bignum, so we have to check. Use a worst-case cost +;;; to make sure people know they may be number consing. (define-vop (move-from-signed) (:args (arg :scs (signed-reg unsigned-reg) :target x)) (:results (y :scs (any-reg descriptor-reg))) @@ -264,10 +247,9 @@ (define-move-vop move-from-signed :move (signed-reg) (descriptor-reg)) - -;;; Check for fixnum, and possibly allocate one or two word bignum result. Use -;;; a worst-case cost to make sure people know they may be number consing. -;;; +;;; Check for fixnum, and possibly allocate one or two word bignum +;;; result. Use a worst-case cost to make sure people know they may be +;;; number consing. (define-vop (move-from-unsigned) (:args (arg :scs (signed-reg unsigned-reg) :target x)) (:results (y :scs (any-reg descriptor-reg))) @@ -299,9 +281,7 @@ (define-move-vop move-from-unsigned :move (unsigned-reg) (descriptor-reg)) - ;;; Move untagged numbers. -;;; (define-vop (word-move) (:args (x :target y :scs (signed-reg unsigned-reg) @@ -317,9 +297,7 @@ (define-move-vop word-move :move (signed-reg unsigned-reg) (signed-reg unsigned-reg)) - ;;; Move untagged number arguments/return-values. -;;; (define-vop (move-word-argument) (:args (x :target y :scs (signed-reg unsigned-reg)) @@ -338,8 +316,7 @@ (descriptor-reg any-reg signed-reg unsigned-reg) (signed-reg unsigned-reg)) -;;; Use standard MOVE-ARGUMENT + coercion to move an untagged number to a -;;; descriptor passing location. -;;; +;;; Use standard MOVE-ARGUMENT + coercion to move an untagged number +;;; to a descriptor passing location. (define-move-vop move-argument :move-argument (signed-reg unsigned-reg) (any-reg descriptor-reg))