[prev in list] [next in list] [prev in thread] [next in thread]
List: sbcl-devel
Subject: Re: [Sbcl-devel] [Sbcl-commits] master: Add support for unboxed entry points.
From: Stas Boukarev <stassats () gmail ! com>
Date: 2022-07-05 18:23:57
Message-ID: CAF63=11T1T8MW+WhanMp7wJQK3TcZq6jy_sEWDCLKUELZRfd4A () mail ! gmail ! com
[Download RAW message or body]
Indeed.
On Tue, Jul 5, 2022 at 9:19 PM Charles Zhang via Sbcl-commits
<sbcl-commits@lists.sourceforge.net> wrote:
>
> Nice!
>
> I think descriptor is misspelled though. (Desctiptor).
>
> On Di., Juli 5, 2022 at 11:13, stassats via Sbcl-commits
> <sbcl-commits@lists.sourceforge.net> wrote:
> The branch "master" has been updated in SBCL:
> via cb1fca7373e41577f673fe7f49e771212284e348 (commit)
> from 4a488e49c6f74bb193ccc6b1e74387d454e74b22 (commit)
>
> - Log -----------------------------------------------------------------
> commit cb1fca7373e41577f673fe7f49e771212284e348
> Author: Stas Boukarev <stassats@gmail.com>
> Date: Tue Jul 5 03:17:38 2022 +0300
>
> Add support for unboxed entry points.
>
> Passing floats in float registers, words in non-descriptor registers.
>
> Implemented on arm64 so far.
> ---
> src/compiler/arm64/call.lisp | 22 ++++--
> src/compiler/arm64/vm.lisp | 5 +-
> src/compiler/fun-info.lisp | 6 +-
> src/compiler/generic/utils.lisp | 26 +++++++
> src/compiler/ir1tran-lambda.lisp | 20 ++++-
> src/compiler/ir2tran.lisp | 162 +++++++++++++++++++++++++--------------
> src/compiler/knownfun.lisp | 5 ++
> src/compiler/locall.lisp | 12 ++-
> src/compiler/meta-vmdef.lisp | 4 +-
> src/compiler/represent.lisp | 31 ++++----
> src/compiler/vop.lisp | 2 +-
> 11 files changed, 203 insertions(+), 92 deletions(-)
>
> diff --git a/src/compiler/arm64/call.lisp b/src/compiler/arm64/call.lisp
> index dc6bca210..9802f6cc3 100644
> --- a/src/compiler/arm64/call.lisp
> +++ b/src/compiler/arm64/call.lisp
> @@ -861,7 +861,7 @@
> ;;; In tail call with fixed arguments, the passing locations are passed as a
> ;;; more arg, but there is no new-FP, since the arguments have been set up in
> ;;; the current frame.
> -(defmacro define-full-call (name named return variable)
> +(defmacro define-full-call (name named return variable &optional args)
> (aver (not (and variable (eq return :tail))))
> `(define-vop (,name
> ,@(when (eq return :unknown)
> @@ -881,15 +881,20 @@
> '((old-fp)
> (return-pc)))
>
> - ,@(unless variable '((args :more t :scs (descriptor-reg)))))
> + ,@(unless variable `((args :more t ,@(unless (eq args :fixed)
> + '(:scs (descriptor-reg)))))))
>
> ,@(when (eq return :fixed)
> '((:results (values :more t))))
>
> (:save-p ,(if (eq return :tail) :compute-only t))
>
> - ,@(unless (or (eq return :tail) variable)
> - '((:move-args :full-call)))
> + ,@(unless (or (eq return :tail)
> + variable)
> + `((:move-args ,(if (eq args :fixed)
> + :fixed
> + :full-call))))
> +
>
> (:vop-var vop)
> (:node-var node)
> @@ -1076,6 +1081,8 @@
> (define-full-call call-variable nil :fixed t)
> (define-full-call multiple-call-variable nil :unknown t)
>
> +(define-full-call fixed-call-named t :fixed nil :fixed)
> +(define-full-call fixed-tail-call-named t :tail nil :fixed)
> ;;; Defined separately, since needs special code that BLT's the
> ;;; arguments down.
> (define-vop (tail-call-variable)
> @@ -1099,9 +1106,9 @@
> (inst add nsp-tn cur-nfp (add-sub-immediate
> (bytes-needed-for-non-descriptor-stack-frame)))))
> (load-inline-constant tmp-tn
> - (if (eq fun-type :function)
> - '(:fixup tail-call-variable :assembly-routine)
> - '(:fixup tail-call-callable-variable \
> :assembly-routine))) + (if (eq fun-type :function)
> + '(:fixup tail-call-variable :assembly-routine)
> + '(:fixup tail-call-callable-variable :assembly-routine)))
> (inst br tmp-tn)))
>
> ;;; Invoke the function-designator FUN.
> @@ -1282,3 +1289,4 @@
> ;; single-step-before-trap.
> (inst brk single-step-before-trap)
> DONE))
> +
> diff --git a/src/compiler/arm64/vm.lisp b/src/compiler/arm64/vm.lisp
> index 6087f8b25..3aac2a21d 100644
> --- a/src/compiler/arm64/vm.lisp
> +++ b/src/compiler/arm64/vm.lisp
> @@ -93,7 +93,10 @@
> (defconstant register-arg-count 4)
> ;; names and offsets for registers used to pass arguments
> (defregset *register-arg-offsets* r0 r1 r2 r3)
> - (defparameter *register-arg-names* '(r0 r1 r2 r3)))
> + (defparameter *register-arg-names* '(r0 r1 r2 r3))
> + (defregset *desctiptor-args* r0 r1 r2 r3 r4 r5 r6 r7 r8 r9)
> + (defregset *non-desctiptor-args* nl0 nl1 nl2 nl3 nl4 nl5 nl6 nl7 nl8 nl9)
> + (defparameter *float-args* (loop for i below 32 collect i)))
>
>
> ;;;; SB and SC definition:
> diff --git a/src/compiler/fun-info.lisp b/src/compiler/fun-info.lisp
> index d88ef04a4..f076905b6 100644
> --- a/src/compiler/fun-info.lisp
> +++ b/src/compiler/fun-info.lisp
> @@ -96,7 +96,11 @@
> reoptimize-when-unlinking
> ;; The function does not verify the arg count and must be always
> ;; called with the right arguments and can avoid passing NARGS.
> - no-verify-arg-count)
> + no-verify-arg-count
> + ;; Arguments are can be passed unboxed, no type checking on entry is
> + ;; performed, and the number of arguments passed in registers can be
> + ;; greater than the standard number. Only fixed arguments can be used.
> + fixed-args)
>
> (defstruct (fun-info (:copier nil)
> #-sb-xc-host (:pure t))
> diff --git a/src/compiler/generic/utils.lisp b/src/compiler/generic/utils.lisp
> index 9e7eec119..8a33d512c 100644
> --- a/src/compiler/generic/utils.lisp
> +++ b/src/compiler/generic/utils.lisp
> @@ -142,6 +142,32 @@
> (nth n *register-arg-offsets*))
> (make-sc+offset control-stack-sc-number n)))
>
> +(defstruct fixed-call-args-state
> + (descriptors -1 :type fixnum)
> + (non-descriptors -1 :type fixnum)
> + (float -1 :type fixnum))
> +
> +(defvar *float-args*)
> +(defvar *non-desctiptor-args*)
> +(defvar *desctiptor-args*)
> +
> +(defun fixed-call-arg-location (type state)
> + (let* ((primtype (primitive-type type))
> + (sc (find descriptor-reg-sc-number (sb-c::primitive-type-scs primtype) \
> :test-not #'eql))) + (case (primitive-type-name primtype)
> + ((double-float single-float)
> + (make-wired-tn primtype
> + sc
> + (elt *float-args* (incf (fixed-call-args-state-float \
> state))))) + ((unsigned-byte-64 signed-byte-64)
> + (make-wired-tn primtype
> + sc
> + (elt *non-desctiptor-args* (incf \
> (fixed-call-args-state-non-descriptors state))))) + (t
> + (make-wired-tn primtype
> + descriptor-reg-sc-number
> + (elt *desctiptor-args* (incf \
> (fixed-call-args-state-descriptors state)))))))) +
> ;;; Make a TN to hold the number-stack frame pointer. This is allocated
> ;;; once per component, and is component-live.
> (defun make-nfp-tn ()
> diff --git a/src/compiler/ir1tran-lambda.lisp b/src/compiler/ir1tran-lambda.lisp
> index aeea5dfaa..18dd679c3 100644
> --- a/src/compiler/ir1tran-lambda.lisp
> +++ b/src/compiler/ir1tran-lambda.lisp
> @@ -873,10 +873,19 @@
>
> (defvar *lambda-conversions*)
>
> +(defun add-types-for-fixed-args (fun vars)
> + (let ((fun-info (info :function :info fun)))
> + (when (and fun-info
> + (ir1-attributep (fun-info-attributes fun-info) fixed-args))
> + (loop for type in (fun-type-required (info :function :type fun))
> + for var in vars
> + do (setf (lambda-var-type var) type))))
> + vars)
> +
> ;;; Convert a LAMBDA form into a LAMBDA leaf or an OPTIONAL-DISPATCH leaf.
> (defun ir1-convert-lambda (form &key (source-name '.anonymous.)
> - debug-name maybe-add-debug-catch
> - system-lambda)
> + debug-name maybe-add-debug-catch
> + system-lambda)
> (unless (consp form)
> (compiler-error "A ~S was found when expecting a lambda expression:~% ~S"
> (type-of form)
> @@ -926,7 +935,8 @@
> > debug-name debug-name
> > system-lambda system-lambda))
> (t
> - (ir1-convert-lambda-body forms vars
> + (ir1-convert-lambda-body forms
> + (add-types-for-fixed-args \
> source-name vars) :aux-vars aux-vars
> > aux-vals aux-vals
> > post-binding-lexenv post-binding-lexenv
> @@ -1018,7 +1028,9 @@
> (defined-fun-same-block-p defined-fun-res) t)
> ;; FIXME: Should non-entry block compiled defuns have
> ;; this propagate?
> - (assert-global-function-definition-type name res)
> + (unless (and info
> + (ir1-attributep (fun-info-attributes info) fixed-args))
> + (assert-global-function-definition-type name res))
> ;; If in a simple environment, then we can allow
> ;; backward references to this function from following
> ;; top-level forms.
> diff --git a/src/compiler/ir2tran.lisp b/src/compiler/ir2tran.lisp
> index 942f83a07..b878aae7c 100644
> --- a/src/compiler/ir2tran.lisp
> +++ b/src/compiler/ir2tran.lisp
> @@ -1073,15 +1073,20 @@
> (let ((args (basic-combination-args node))
> (last nil)
> (first nil))
> - (dotimes (num (length args))
> - (let ((loc (standard-arg-location num)))
> - (emit-move node block (lvar-tn node block (elt args num)) loc)
> - (let ((ref (reference-tn loc nil)))
> - (if last
> - (setf (tn-ref-across last) ref)
> - (setf first ref))
> - (setq last ref))))
> - first))
> + (multiple-value-bind (fixed-args-state fixed-args-types)
> + (fixed-args-state node)
> + (dotimes (num (length args))
> + (let ((loc (cond (fixed-args-state
> + (sb-vm::fixed-call-arg-location (pop fixed-args-types) \
> fixed-args-state)) + (t
> + (standard-arg-location num)))))
> + (emit-move node block (lvar-tn node block (elt args num)) loc)
> + (let ((ref (reference-tn loc nil)))
> + (if last
> + (setf (tn-ref-across last) ref)
> + (setf first ref))
> + (setq last ref))))
> + (values first fixed-args-state))))
>
> #+call-symbol
> (defun fun-tn-type (lvar tn)
> @@ -1110,62 +1115,83 @@
> (let* ((env (environment-info (node-environment node)))
> (args (basic-combination-args node))
> (nargs (length args))
> - (pass-refs (move-tail-full-call-args node block))
> (old-fp (ir2-environment-old-fp env))
> (return-pc (ir2-environment-return-pc env))
> (fun-lvar (basic-combination-fun node))
> (nargs (if (pass-nargs-p node)
> nargs
> (list nargs))))
> - (multiple-value-bind (fun-tn named)
> - (fun-lvar-tn node block fun-lvar)
> - (cond ((not named)
> - (vop* tail-call node block
> - (fun-tn old-fp return-pc pass-refs)
> - (nil)
> - nargs (emit-step-p node)
> - #+call-symbol
> - (fun-tn-type fun-lvar fun-tn)))
> - #-immobile-code
> - ((eq fun-tn named)
> - (vop* static-tail-call-named node block
> - (old-fp return-pc pass-refs) ; args
> - (nil) ; results
> - nargs named (emit-step-p node)))
> - (t
> - (vop* tail-call-named node block
> - (#-immobile-code fun-tn old-fp return-pc pass-refs) ; args
> - (nil) ; results
> - nargs #+immobile-code named (emit-step-p node)))))) ; info
> + (multiple-value-bind (pass-refs fixed-args-p)
> + (move-tail-full-call-args node block)
> + (multiple-value-bind (fun-tn named)
> + (fun-lvar-tn node block fun-lvar)
> + (cond ((not named)
> + (vop* tail-call node block
> + (fun-tn old-fp return-pc pass-refs)
> + (nil)
> + nargs (emit-step-p node)
> + #+call-symbol
> + (fun-tn-type fun-lvar fun-tn)))
> + #-immobile-code
> + ((eq fun-tn named)
> + (vop* static-tail-call-named node block
> + (old-fp return-pc pass-refs) ; args
> + (nil) ; results
> + nargs named (emit-step-p node)))
> + (fixed-args-p
> + (when-vop-existsp (:named sb-vm::fixed-tail-call-named)
> + (vop* sb-vm::fixed-tail-call-named node block
> + (#-immobile-code fun-tn old-fp return-pc pass-refs) ; args
> + (nil) ; results
> + nargs #+immobile-code named (emit-step-p node))))
> + (t
> + (vop* tail-call-named node block
> + (#-immobile-code fun-tn old-fp return-pc pass-refs) ; args
> + (nil) ; results
> + nargs #+immobile-code named (emit-step-p node))))))) ; info
> (values))
>
> +(defun fixed-args-state (node)
> + (let ((info (combination-fun-info node)))
> + (when (and info
> + (ir1-attributep (fun-info-attributes info) fixed-args))
> + (values (sb-vm::make-fixed-call-args-state)
> + (fun-type-required (info :function :type \
> (combination-fun-source-name node) )))))) +
> ;;; like IR2-CONVERT-LOCAL-CALL-ARGS, only different
> (defun ir2-convert-full-call-args (node block)
> (declare (type combination node) (type ir2-block block))
> (let* ((args (basic-combination-args node))
> (nargs (length args))
> (fp (make-stack-pointer-tn nargs)))
> - (vop allocate-full-call-frame node block nargs fp)
> - (collect ((locs))
> - (let ((last nil)
> - (first nil))
> - (dotimes (num nargs)
> - (locs (sb-vm::standard-call-arg-location num))
> - (let ((ref (reference-tn (lvar-tn node block (elt args num))
> - nil)))
> - (if last
> - (setf (tn-ref-across last) ref)
> - (setf first ref))
> - (setq last ref)))
> + (multiple-value-bind (fixed-args-state fixed-args-types)
> + (fixed-args-state node)
> + (vop allocate-full-call-frame node block nargs fp)
> + (collect ((locs))
> + (let ((last nil)
> + (first nil))
> + (dotimes (num nargs)
> + (let* ((arg (elt args num))
> + (ref (reference-tn (lvar-tn node block arg)
> + nil)))
> + (locs
> + (cond (fixed-args-state
> + (sb-vm::fixed-call-arg-location (pop fixed-args-types) \
> fixed-args-state)) + (t
> + (sb-vm::standard-call-arg-location num))))
>
> - (values fp first (locs) nargs)))))
> + (if last
> + (setf (tn-ref-across last) ref)
> + (setf first ref))
> + (setq last ref)))
> + (values fp first (locs) nargs fixed-args-state))))))
>
> ;;; Do full call when a fixed number of values are desired. We make
> ;;; STANDARD-RESULT-TNS for our lvar, then deliver the result using
> ;;; MOVE-LVAR-RESULT. We do named or normal call, as appropriate.
> (defun ir2-convert-fixed-full-call (node block)
> (declare (type combination node) (type ir2-block block))
> - (multiple-value-bind (fp args arg-locs nargs)
> + (multiple-value-bind (fp args arg-locs nargs fixed-args-p)
> (ir2-convert-full-call-args node block)
> (let* ((lvar (node-lvar node))
> (locs (and lvar
> @@ -1198,6 +1224,13 @@
> (loc-refs)
> arg-locs nargs named nvals
> (emit-step-p node)))
> + (fixed-args-p
> + (when-vop-existsp (:named sb-vm::fixed-call-named)
> + (vop* sb-vm::fixed-call-named node block
> + (fp #-immobile-code fun-tn args) ; args
> + (loc-refs) ; results
> + arg-locs nargs #+immobile-code named nvals ; info
> + (emit-step-p node))))
> (t
> (vop* call-named node block
> (fp #-immobile-code fun-tn args) ; args
> @@ -1427,21 +1460,32 @@
> (vop setup-closure-environment node block start-label closure)
> (let ((n -1))
> (dolist (loc (ir2-environment-closure env))
> - (vop closure-ref node block closure (incf n) (cdr loc)))))))
> - (unless (eq (functional-kind fun) :toplevel)
> - (let ((vars (lambda-vars fun))
> - (n 0))
> - (when (leaf-refs (first vars))
> - (emit-move node block arg-count-tn (leaf-info (first vars))))
> - (dolist (arg (rest vars))
> - (when (leaf-refs arg)
> - (let ((pass (standard-arg-location n))
> - (home (leaf-info arg)))
> - (if (and (lambda-var-indirect arg)
> - (lambda-var-explicit-value-cell arg))
> - (emit-make-value-cell node block pass home)
> - (emit-move node block pass home))))
> - (incf n))))
> + (vop closure-ref node block closure (incf n) (cdr loc))))))
> + (unless (eq (functional-kind fun) :toplevel)
> + (let* ((vars (lambda-vars fun))
> + (n 0)
> + (name (functional-%source-name ef))
> + (fun-info (info :function :info name))
> + (fixed-args
> + (and fun-info
> + (ir1-attributep (fun-info-attributes fun-info) fixed-args)))
> + (arg-types (and fixed-args
> + (fun-type-required (info :function :type name))))
> + (fixed-arg-state (and fixed-args
> + (sb-vm::make-fixed-call-args-state))))
> + (when (leaf-refs (first vars))
> + (emit-move node block arg-count-tn (leaf-info (first vars))))
> + (dolist (arg (rest vars))
> + (when (leaf-refs arg)
> + (let ((pass (if fixed-args
> + (sb-vm::fixed-call-arg-location (pop arg-types) \
> fixed-arg-state) + (standard-arg-location n)))
> + (home (leaf-info arg)))
> + (if (and (lambda-var-indirect arg)
> + (lambda-var-explicit-value-cell arg))
> + (emit-make-value-cell node block pass home)
> + (emit-move node block pass home))))
> + (incf n)))))
> #-fp-and-pc-standard-save
> (emit-move node block (make-old-fp-passing-location)
> (ir2-environment-old-fp env)))
> diff --git a/src/compiler/knownfun.lisp b/src/compiler/knownfun.lisp
> index a43a65317..1e45629f2 100644
> --- a/src/compiler/knownfun.lisp
> +++ b/src/compiler/knownfun.lisp
> @@ -173,6 +173,11 @@
> (pushnew 'unsafely-flushable attributes))
> #-(or x86-64 arm64) ;; Needs to be supported by the call VOPs
> (setf attributes (remove 'no-verify-arg-count attributes))
> + #-arm64 ;; Needs to be supported by the call VOPs, \
> sb-vm::fixed-call-arg-location + (setf attributes (remove 'fixed-args attributes))
> + (when (memq 'fixed-args attributes)
> + (pushnew 'no-verify-arg-count attributes))
> +
> (multiple-value-bind (type annotation)
> (split-type-info arg-types result-type)
> `(%defknown ',(if (and (consp name)
> diff --git a/src/compiler/locall.lisp b/src/compiler/locall.lisp
> index d7f61b3f9..9e4bc273c 100644
> --- a/src/compiler/locall.lisp
> +++ b/src/compiler/locall.lisp
> @@ -178,10 +178,18 @@
> (clambda
> (let* ((n-supplied (gensym))
> (nargs (length (lambda-vars fun)))
> - (temps (make-gensym-list nargs)))
> + (temps (make-gensym-list nargs))
> + (info (info :function :info (functional-%source-name fun)))
> + (types (and info
> + (ir1-attributep (fun-info-attributes info) fixed-args)
> + (loop for var in (lambda-vars fun)
> + for temp in temps
> + collect `(type ,(type-specifier (lambda-var-type \
> var)) ,temp))))) +
> `(lambda (,n-supplied ,@temps)
> (declare (type index ,n-supplied)
> - (ignore ,n-supplied))
> + (ignore ,n-supplied)
> + ,@types)
> (%funcall ,fun ,@temps))))
> (optional-dispatch
> ;; Force conversion of all entries
> diff --git a/src/compiler/meta-vmdef.lisp b/src/compiler/meta-vmdef.lisp
> index b4572c148..5b0233cfd 100644
> --- a/src/compiler/meta-vmdef.lisp
> +++ b/src/compiler/meta-vmdef.lisp
> @@ -341,7 +341,7 @@
> (save-p nil :type (member t nil :compute-only :force-to-stack))
> ;; info about how to emit MOVE-ARG VOPs for the &MORE operand in
> ;; call/return VOPs
> - (move-args nil :type (member nil :local-call :full-call :known-return))
> + (move-args nil :type (member nil :local-call :full-call :known-return :fixed))
> (args-var '.args. :type symbol)
> (results-var '.results. :type symbol)
> (before-load :unspecified :type (or (member :unspecified) list)))
> @@ -1065,7 +1065,7 @@
> (:move-args
> (setf (vop-parse-move-args parse)
> (vop-spec-arg spec '(member nil :local-call :full-call
> - :known-return))))
> + :known-return :fixed))))
> (:node-var
> (setf (vop-parse-node-var parse) (vop-spec-arg spec 'symbol)))
> (:note
> diff --git a/src/compiler/represent.lisp b/src/compiler/represent.lisp
> index 12085f5b7..0591bd155 100644
> --- a/src/compiler/represent.lisp
> +++ b/src/compiler/represent.lisp
> @@ -569,21 +569,22 @@
>
> (change-tn-ref-tn val pass-tn)
> (let* ((this-fp
> - (cond ((not (sc-number-stack-p pass-sc)) fp-tn)
> - (nfp-tn)
> - (t
> - (aver (eq how :known-return))
> - (setq nfp-tn (make-number-stack-pointer-tn))
> - (setf (tn-sc nfp-tn)
> - (svref *backend-sc-numbers*
> - (first (primitive-type-scs
> - (tn-primitive-type nfp-tn)))))
> - (emit-context-template
> - node block
> - (template-or-lose 'compute-old-nfp)
> - nfp-tn vop)
> - (aver (not (sc-number-stack-p (tn-sc nfp-tn))))
> - nfp-tn)))
> + (cond ((or (eq how :fixed)
> + (not (sc-number-stack-p pass-sc))) fp-tn)
> + (nfp-tn)
> + (t
> + (aver (eq how :known-return))
> + (setq nfp-tn (make-number-stack-pointer-tn))
> + (setf (tn-sc nfp-tn)
> + (svref *backend-sc-numbers*
> + (first (primitive-type-scs
> + (tn-primitive-type nfp-tn)))))
> + (emit-context-template
> + node block
> + (template-or-lose 'compute-old-nfp)
> + nfp-tn vop)
> + (aver (not (sc-number-stack-p (tn-sc nfp-tn))))
> + nfp-tn)))
> (new (emit-move-arg-template node block res val-tn this-fp
> pass-tn vop))
> (after
> diff --git a/src/compiler/vop.lisp b/src/compiler/vop.lisp
> index dff37df80..99b4d9372 100644
> --- a/src/compiler/vop.lisp
> +++ b/src/compiler/vop.lisp
> @@ -695,7 +695,7 @@
> ;;
> ;; :KNOWN-RETURN
> ;; If needed, the old NFP is computed using COMPUTE-OLD-NFP.
> - (move-args nil :type (member nil :full-call :local-call :known-return))
> + (move-args nil :type (member nil :full-call :local-call :known-return :fixed))
> ;; a list of sc-vectors representing the loading costs of each fixed
> ;; argument and result
> (arg-costs nil :type list)
>
> -----------------------------------------------------------------------
>
>
> hooks/post-receive
> --
> SBCL
>
>
> _______________________________________________
> Sbcl-commits mailing list
> Sbcl-commits@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/sbcl-commits
>
> _______________________________________________
> Sbcl-commits mailing list
> Sbcl-commits@lists.sourceforge.net
> https://lists.sourceforge.net/lists/listinfo/sbcl-commits
_______________________________________________
Sbcl-devel mailing list
Sbcl-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/sbcl-devel
[prev in list] [next in list] [prev in thread] [next in thread]
Configure |
About |
News |
Add a list |
Sponsored by KoreLogic