X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fdebug-dump.lisp;h=9e3630a589d89e5193acbba380ee00f42d19f4eb;hb=ace140856e6b3f92bb06597092a59753f1e59142;hp=b12a7437a2ad6c32b04bcc3b477bfe5075ea8573;hpb=cd71fa005a6168cf9c79eca38459210bdd9a6c4b;p=sbcl.git diff --git a/src/compiler/debug-dump.lisp b/src/compiler/debug-dump.lisp index b12a743..9e3630a 100644 --- a/src/compiler/debug-dump.lisp +++ b/src/compiler/debug-dump.lisp @@ -71,7 +71,7 @@ (when (and (lambda-var-p leaf) (or (not (member (tn-kind tn) '(:environment :debug-environment))) - (rassoc leaf (lexenv-variables (node-lexenv node)))) + (rassoc leaf (lexenv-vars (node-lexenv node)))) (or (null spilled) (not (member tn spilled)))) (let ((num (gethash leaf var-locs))) @@ -141,11 +141,10 @@ (when (eq (block-info block) 2block) (unless (eql (source-path-tlf-number (node-source-path - (continuation-next - (block-start block)))) + (block-start-node block))) res) (setq res nil))) - + (dolist (loc (ir2-block-locations 2block)) (unless (eql (source-path-tlf-number (node-source-path @@ -163,7 +162,7 @@ (write-var-integer (length locations) *byte-buffer*) (let ((2block (block-info block))) (write-var-integer (+ (length locations) 1) *byte-buffer*) - (dump-1-location (continuation-next (block-start block)) + (dump-1-location (block-start-node block) 2block :block-start tlf-num (ir2-block-%label 2block) (ir2-block-live-out 2block) @@ -240,7 +239,7 @@ ;;; Return a list of DEBUG-SOURCE structures containing information ;;; derived from INFO. Unless :BYTE-COMPILE T was specified, we always -;;; dump the Start-Positions, since it is too hard figure out whether +;;; dump the START-POSITIONS, since it is too hard figure out whether ;;; we need them or not. (defun debug-source-for-info (info) (declare (type source-info info)) @@ -262,6 +261,14 @@ (let* ((untruename (file-info-untruename file-info)) (dir (pathname-directory untruename))) (setf (debug-source-name res) + #+sb-xc-host + (let ((src (position "src" dir :test #'string= :from-end t))) + (if src + (format nil "SYS:~{~:@(~A~);~}~:@(~A~).LISP" + (subseq dir src) (pathname-name untruename)) + ;; FIXME: just output/stuff-groveled-from-headers.lisp + (namestring untruename))) + #-sb-xc-host (namestring (if (and dir (eq (first dir) :absolute)) untruename @@ -277,12 +284,7 @@ ;;; a vector whose element size is an integer multiple of output byte ;;; size. (defun coerce-to-smallest-eltype (seq) - (let ((maxoid #-sb-xc-host 0 - ;; An initial value of 255 prevents us from - ;; specializing the array to anything smaller than - ;; (UNSIGNED-BYTE 8), which keeps the cross-compiler's - ;; portable specialized array output functions happy. - #+sb-xc-host 255)) + (let ((maxoid 0)) (flet ((frob (x) (if (typep x 'unsigned-byte) (when (>= x maxoid) @@ -294,7 +296,30 @@ (frob i)) (dovector (i seq) (frob i))) - (coerce seq `(simple-array (integer 0 ,maxoid) (*)))))) + (let ((specializer `(unsigned-byte + ,(etypecase maxoid + ((unsigned-byte 8) 8) + ((unsigned-byte 16) 16) + ((unsigned-byte 32) 32))))) + ;; cross-compilers beware! It would be possible for the + ;; upgraded-array-element-type of (UNSIGNED-BYTE 16) to be + ;; (SIGNED-BYTE 17) or (UNSIGNED-BYTE 23), and this is + ;; completely valid by ANSI. However, the cross-compiler + ;; doesn't know how to dump (in practice) anything but the + ;; above three specialized array types, so make it break here + ;; if this is violated. + #+sb-xc-host + (aver + ;; not SB!XC:UPGRADED-ARRAY-ELEMENT-TYPE, because we are + ;; worried about whether the host's implementation of arrays. + (let ((uaet (upgraded-array-element-type specializer))) + (dolist (et '((unsigned-byte 8) + (unsigned-byte 16) + (unsigned-byte 32)) + nil) + (when (and (subtypep et uaet) (subtypep uaet et)) + (return t))))) + (coerce seq `(simple-array ,specializer (*))))))) ;;;; variables @@ -313,7 +338,7 @@ ;;; environment live and is an argument. If a :DEBUG-ENVIRONMENT TN, ;;; then we also exclude set variables, since the variable is not ;;; guaranteed to be live everywhere in that case. -(defun dump-1-variable (fun var tn id minimal buffer) +(defun dump-1-var (fun var tn id minimal buffer) (declare (type lambda-var var) (type (or tn null) tn) (type index id) (type clambda fun)) (let* ((name (leaf-debug-name var)) @@ -348,12 +373,12 @@ (vector-push-extend (tn-sc-offset save-tn) buffer))) (values)) -;;; Return a vector suitable for use as the DEBUG-FUN-VARIABLES +;;; Return a vector suitable for use as the DEBUG-FUN-VARS ;;; of FUN. LEVEL is the current DEBUG-INFO quality. VAR-LOCS is a ;;; hash table in which we enter the translation from LAMBDA-VARS to ;;; the relative position of that variable's location in the resulting ;;; vector. -(defun compute-variables (fun level var-locs) +(defun compute-vars (fun level var-locs) (declare (type clambda fun) (type hash-table var-locs)) (collect ((vars)) (labels ((frob-leaf (leaf tn gensym-p) @@ -375,8 +400,8 @@ (frob-lambda let (= level 3))))) (let ((sorted (sort (vars) #'string< - :key #'(lambda (x) - (symbol-name (leaf-debug-name (car x)))))) + :key (lambda (x) + (symbol-name (leaf-debug-name (car x)))))) (prev-name nil) (id 0) (i 0) @@ -390,18 +415,18 @@ (incf id)) (t (setq id 0 prev-name name))) - (dump-1-variable fun var (cdr x) id nil buffer) + (dump-1-var fun var (cdr x) id nil buffer) (setf (gethash var var-locs) i)) (incf i)) (coerce buffer 'simple-vector)))) -;;; Return a vector suitable for use as the DEBUG-FUN-VARIABLES of +;;; Return a vector suitable for use as the DEBUG-FUN-VARS of ;;; FUN, representing the arguments to FUN in minimal variable format. -(defun compute-minimal-variables (fun) +(defun compute-minimal-vars (fun) (declare (type clambda fun)) (let ((buffer (make-array 0 :fill-pointer 0 :adjustable t))) (dolist (var (lambda-vars fun)) - (dump-1-variable fun var (leaf-info var) 0 t buffer)) + (dump-1-var fun var (leaf-info var) 0 t buffer)) (coerce buffer 'simple-vector))) ;;; Return VAR's relative position in the function's variables (determined @@ -417,14 +442,14 @@ ;;;; arguments/returns -;;; Return a vector to be used as the -;;; COMPILED-DEBUG-FUN-ARGUMENTS for Fun. If fun is the -;;; MAIN-ENTRY for an optional dispatch, then look at the ARGLIST to -;;; determine the syntax, otherwise pretend all arguments are fixed. +;;; Return a vector to be used as the COMPILED-DEBUG-FUN-ARGS for FUN. +;;; If FUN is the MAIN-ENTRY for an optional dispatch, then look at +;;; the ARGLIST to determine the syntax, otherwise pretend all +;;; arguments are fixed. ;;; ;;; ### This assumption breaks down in EPs other than the main-entry, ;;; since they may or may not have supplied-p vars, etc. -(defun compute-arguments (fun var-locs) +(defun compute-args (fun var-locs) (declare (type clambda fun) (type hash-table var-locs)) (collect ((res)) (let ((od (lambda-optional-dispatch fun))) @@ -461,8 +486,8 @@ ;;; (Must be known values return...) (defun compute-debug-returns (fun) (coerce-to-smallest-eltype - (mapcar #'(lambda (loc) - (tn-sc-offset loc)) + (mapcar (lambda (loc) + (tn-sc-offset loc)) (return-info-locations (tail-set-info (lambda-tail-set fun)))))) ;;;; debug functions @@ -498,21 +523,23 @@ (let ((od (lambda-optional-dispatch fun))) (or (not od) (not (eq (optional-dispatch-main-entry od) fun))))) - (setf (compiled-debug-fun-variables dfun) - (compute-minimal-variables fun)) + (setf (compiled-debug-fun-vars dfun) + (compute-minimal-vars fun)) (setf (compiled-debug-fun-arguments dfun) :minimal)) (t - (setf (compiled-debug-fun-variables dfun) - (compute-variables fun level var-locs)) + (setf (compiled-debug-fun-vars dfun) + (compute-vars fun level var-locs)) (setf (compiled-debug-fun-arguments dfun) - (compute-arguments fun var-locs)))) + (compute-args fun var-locs)))) - (when (>= level 2) - (multiple-value-bind (blocks tlf-num) (compute-debug-blocks fun var-locs) - (setf (compiled-debug-fun-tlf-number dfun) tlf-num) - (setf (compiled-debug-fun-blocks dfun) blocks))) + (if (>= level 2) + (multiple-value-bind (blocks tlf-num) + (compute-debug-blocks fun var-locs) + (setf (compiled-debug-fun-tlf-number dfun) tlf-num) + (setf (compiled-debug-fun-blocks dfun) blocks)) + (setf (compiled-debug-fun-tlf-number dfun) (find-tlf-number fun))) - (if (external-entry-point-p fun) + (if (xep-p fun) (setf (compiled-debug-fun-returns dfun) :standard) (let ((info (tail-set-info (lambda-tail-set fun)))) (when info @@ -545,20 +572,21 @@ ;;; called after assembly so that source map information is available. (defun debug-info-for-component (component) (declare (type component component)) - (collect ((dfuns)) - (let ((var-locs (make-hash-table :test 'eq)) - (*byte-buffer* (make-array 10 - :element-type '(unsigned-byte 8) - :fill-pointer 0 - :adjustable t))) - (dolist (fun (component-lambdas component)) - (clrhash var-locs) - (dfuns (cons (label-position (block-label (lambda-block fun))) - (compute-1-debug-fun fun var-locs)))) - (let* ((sorted (sort (dfuns) #'< :key #'car)) - (fun-map (compute-debug-fun-map sorted))) - (make-compiled-debug-info :name (component-name component) - :fun-map fun-map))))) + (let ((dfuns nil) + (var-locs (make-hash-table :test 'eq)) + (*byte-buffer* (make-array 10 + :element-type '(unsigned-byte 8) + :fill-pointer 0 + :adjustable t))) + (dolist (lambda (component-lambdas component)) + (clrhash var-locs) + (push (cons (label-position (block-label (lambda-block lambda))) + (compute-1-debug-fun lambda var-locs)) + dfuns)) + (let* ((sorted (sort dfuns #'< :key #'car)) + (fun-map (compute-debug-fun-map sorted))) + (make-compiled-debug-info :name (component-name component) + :fun-map fun-map)))) ;;; Write BITS out to BYTE-BUFFER in backend byte order. The length of ;;; BITS must be evenly divisible by eight.