X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Ftarget-disassem.lisp;h=878935359971dbfeda1cd6e9885a0ea210c97428;hb=56ce3857f7830670d55d2fe17246353dff2e71f7;hp=20f14dc30e0a29c2ab2189ff30e96b79b5110e1c;hpb=7e6637658236983ecbabea50f167fb9d3c5ed505;p=sbcl.git diff --git a/src/compiler/target-disassem.lisp b/src/compiler/target-disassem.lisp index 20f14dc..8789353 100644 --- a/src/compiler/target-disassem.lisp +++ b/src/compiler/target-disassem.lisp @@ -218,7 +218,7 @@ ;;; ;;; start of instructions ;;; ... -;;; function-headers and lra's buried in here randomly +;;; fun-headers and lra's buried in here randomly ;;; ... ;;; start of trace-table ;;; @@ -252,13 +252,13 @@ (defstruct (offs-hook (:copier nil)) (offset 0 :type offset) - (function (required-argument) :type function) + (function (missing-arg) :type function) (before-address nil :type (member t nil))) (defstruct (segment (:conc-name seg-) (:constructor %make-segment) (:copier nil)) - (sap-maker (required-argument) + (sap-maker (missing-arg) :type (function () sb!sys:system-area-pointer)) (length 0 :type length) (virtual-location 0 :type address) @@ -281,43 +281,48 @@ (defstruct (disassem-state (:conc-name dstate-) (:constructor %make-dstate) (:copier nil)) - (cur-offs 0 :type offset) ; offset of current pos in segment - (next-offs 0 :type offset) ; offset of next position - - (segment-sap (required-argument) :type sb!sys:system-area-pointer) - ; a sap pointing to our segment - (segment nil :type (or null segment)) ; the current segment - - (alignment sb!vm:word-bytes :type alignment) ; what to align to in most cases + ;; offset of current pos in segment + (cur-offs 0 :type offset) + ;; offset of next position + (next-offs 0 :type offset) + ;; a sap pointing to our segment + (segment-sap (missing-arg) :type sb!sys:system-area-pointer) + ;; the current segment + (segment nil :type (or null segment)) + ;; what to align to in most cases + (alignment sb!vm:n-word-bytes :type alignment) (byte-order :little-endian :type (member :big-endian :little-endian)) - - (properties nil :type list) ; for user code to hang stuff off of + ;; for user code to hang stuff off of + (properties nil :type list) (filtered-values (make-array max-filtered-value-index) :type filtered-value-vector) - - (addr-print-len nil :type ; used for prettifying printing - (or null (integer 0 20))) + ;; used for prettifying printing + (addr-print-len nil :type (or null (integer 0 20))) (argument-column 0 :type column) - (output-state :beginning ; to make output look nicer + ;; to make output look nicer + (output-state :beginning :type (member :beginning :block-boundary nil)) - (labels nil :type list) ; alist of (address . label-number) - (label-hash (make-hash-table) ; same thing in a different form - :type hash-table) - - (fun-hooks nil :type list) ; list of function + ;; alist of (address . label-number) + (labels nil :type list) + ;; same as LABELS slot data, but in a different form + (label-hash (make-hash-table) :type hash-table) + ;; list of function + (fun-hooks nil :type list) - ;; these next two are popped as they are used - (cur-labels nil :type list) ; alist of (address . label-number) - (cur-offs-hooks nil :type list) ; list of offs-hook + ;; alist of (address . label-number), popped as it's used + (cur-labels nil :type list) ; + ;; list of offs-hook, popped as it's used + (cur-offs-hooks nil :type list) - (notes nil :type list) ; for the current location + ;; for the current location + (notes nil :type list) - (current-valid-locations nil ; currently active source variables - :type (or null (vector bit)))) + ;; currently active source variables + (current-valid-locations nil :type (or null (vector bit)))) (def!method print-object ((dstate disassem-state) stream) (print-unreadable-object (dstate stream :type t) (format stream @@ -339,19 +344,19 @@ (defun fun-self (fun) (declare (type compiled-function fun)) - (sb!kernel:%function-self fun)) + (sb!kernel:%simple-fun-self fun)) (defun fun-code (fun) (declare (type compiled-function fun)) - (sb!kernel:function-code-header (fun-self fun))) + (sb!kernel:fun-code-header (fun-self fun))) (defun fun-next (fun) (declare (type compiled-function fun)) - (sb!kernel:%function-next fun)) + (sb!kernel:%simple-fun-next fun)) (defun fun-address (function) (declare (type compiled-function function)) - (- (sb!kernel:get-lisp-obj-address function) sb!vm:function-pointer-type)) + (- (sb!kernel:get-lisp-obj-address function) sb!vm:fun-pointer-lowtag)) ;;; the offset of FUNCTION from the start of its code-component's ;;; instruction area @@ -421,7 +426,7 @@ (type disassem-state dstate)) (when (and (aligned-p (+ (seg-virtual-location (dstate-segment dstate)) (dstate-cur-offs dstate)) - (* 2 sb!vm:word-bytes)) + (* 2 sb!vm:n-word-bytes)) ;; Check type. (= (sb!sys:sap-ref-8 (dstate-segment-sap dstate) (if (eq (dstate-byte-order dstate) @@ -429,13 +434,13 @@ (dstate-cur-offs dstate) (+ (dstate-cur-offs dstate) (1- lra-size)))) - sb!vm:return-pc-header-type)) + sb!vm:return-pc-header-widetag)) (unless (null stream) (princ '.lra stream)) (incf (dstate-next-offs dstate) lra-size)) nil) -;;; Print the function-header (entry-point) pseudo-instruction at the +;;; Print the fun-header (entry-point) pseudo-instruction at the ;;; current location in DSTATE to STREAM. (defun fun-header-hook (stream dstate) (declare (type (or null stream) stream) @@ -448,19 +453,22 @@ (segment-offs-to-code-offs (dstate-cur-offs dstate) seg))) (name (sb!kernel:code-header-ref code - (+ woffs sb!vm:function-name-slot))) + (+ woffs + sb!vm:simple-fun-name-slot))) (args (sb!kernel:code-header-ref code - (+ woffs sb!vm:function-arglist-slot))) + (+ woffs + sb!vm:simple-fun-arglist-slot))) (type (sb!kernel:code-header-ref code - (+ woffs sb!vm:function-type-slot)))) + (+ woffs + sb!vm:simple-fun-type-slot)))) (format stream ".~A ~S~:A" 'entry name args) (note (lambda (stream) (format stream "~:S" type)) ; use format to print NIL as () dstate))) (incf (dstate-next-offs dstate) - (words-to-bytes sb!vm:function-code-offset))) + (words-to-bytes sb!vm:simple-fun-code-offset))) (defun alignment-hook (chunk stream dstate) (declare (type dchunk chunk) @@ -529,7 +537,7 @@ (let ((alignment (dstate-alignment dstate))) (unless (null stream) (multiple-value-bind (words bytes) - (truncate alignment sb!vm:word-bytes) + (truncate alignment sb!vm:n-word-bytes) (when (> words 0) (print-words words stream dstate)) (when (> bytes 0) @@ -771,7 +779,7 @@ (string (write-string note stream)) (function - (funcall note stream)))) + (funcall note stream)))) (terpri stream)) (fresh-line stream) (setf (dstate-notes dstate) nil))) @@ -802,19 +810,19 @@ (unless (zerop word-offs) (write-string ", " stream)) (let ((word 0) (bit-shift 0)) - (dotimes (byte-offs sb!vm:word-bytes) + (dotimes (byte-offs sb!vm:n-word-bytes) (let ((byte (sb!sys:sap-ref-8 sap (+ start-offs - (* word-offs sb!vm:word-bytes) + (* word-offs sb!vm:n-word-bytes) byte-offs)))) (setf word (if (eq byte-order :big-endian) - (+ (ash word sb!vm:byte-bits) byte) + (+ (ash word sb!vm:n-byte-bits) byte) (+ word (ash byte bit-shift)))) - (incf bit-shift sb!vm:byte-bits))) - (format stream "#X~V,'0X" (ash sb!vm:word-bits -2) word))))) + (incf bit-shift sb!vm:n-byte-bits))) + (format stream "#X~V,'0X" (ash sb!vm:n-word-bits -2) word))))) (defvar *default-dstate-hooks* (list #'lra-hook)) @@ -891,18 +899,18 @@ ;;; SAP-MAKER and LENGTH bytes long in the disassem-state object DSTATE. ;;; ;;; &KEY arguments include :VIRTUAL-LOCATION (by default the same as -;;; the address), :DEBUG-FUNCTION, :SOURCE-FORM-CACHE (a +;;; the address), :DEBUG-FUN, :SOURCE-FORM-CACHE (a ;;; SOURCE-FORM-CACHE object), and :HOOKS (a list of OFFS-HOOK ;;; objects). (defun make-segment (sap-maker length &key code virtual-location - debug-function source-form-cache + debug-fun source-form-cache hooks) (declare (type (function () sb!sys:system-area-pointer) sap-maker) (type length length) (type (or null address) virtual-location) - (type (or null sb!di:debug-function) debug-function) + (type (or null sb!di:debug-fun) debug-fun) (type (or null source-form-cache) source-form-cache)) (let* ((segment (%make-segment @@ -912,7 +920,7 @@ (sb!sys:sap-int (funcall sap-maker))) :hooks hooks :code code))) - (add-debugging-hooks segment debug-function source-form-cache) + (add-debugging-hooks segment debug-fun source-form-cache) (add-fun-header-hooks segment) segment)) @@ -937,7 +945,7 @@ (defun print-fun-headers (function) (declare (type compiled-function function)) (let* ((self (fun-self function)) - (code (sb!kernel:function-code-header self))) + (code (sb!kernel:fun-code-header self))) (format t "Code-header ~S: size: ~S, trace-table-offset: ~S~%" code (sb!kernel:code-header-ref code @@ -954,24 +962,24 @@ fun fun-offset (sb!kernel:code-header-ref - code (+ fun-offset sb!vm:function-name-slot)) + code (+ fun-offset sb!vm:simple-fun-name-slot)) (sb!kernel:code-header-ref - code (+ fun-offset sb!vm:function-arglist-slot)) + code (+ fun-offset sb!vm:simple-fun-arglist-slot)) (sb!kernel:code-header-ref - code (+ fun-offset sb!vm:function-type-slot))))))) + code (+ fun-offset sb!vm:simple-fun-type-slot))))))) ;;; getting at the source code... (defstruct (source-form-cache (:conc-name sfcache-) (:copier nil)) (debug-source nil :type (or null sb!di:debug-source)) - (top-level-form-index -1 :type fixnum) - (top-level-form nil :type list) + (toplevel-form-index -1 :type fixnum) + (toplevel-form nil :type list) (form-number-mapping-table nil :type (or null (vector list))) (last-location-retrieved nil :type (or null sb!di:code-location)) (last-form-retrieved -1 :type fixnum)) -(defun get-top-level-form (debug-source tlf-index) +(defun get-toplevel-form (debug-source tlf-index) (let ((name (sb!di:debug-source-name debug-source))) (ecase (sb!di:debug-source-from debug-source) (:file @@ -997,7 +1005,8 @@ (file-position f char-offset)) (t (warn "Source file ~S has been modified; ~@ - using form offset instead of file index." + using form offset instead of ~ + file index." name) (let ((*read-suppress* t)) (dotimes (i local-tlf-index) (read f))))) @@ -1017,41 +1026,41 @@ (and cache (and (eq (sb!di:code-location-debug-source loc) (sfcache-debug-source cache)) - (eq (sb!di:code-location-top-level-form-offset loc) - (sfcache-top-level-form-index cache))))) + (eq (sb!di:code-location-toplevel-form-offset loc) + (sfcache-toplevel-form-index cache))))) (defun get-source-form (loc context &optional cache) (let* ((cache-valid (cache-valid loc cache)) - (tlf-index (sb!di:code-location-top-level-form-offset loc)) + (tlf-index (sb!di:code-location-toplevel-form-offset loc)) (form-number (sb!di:code-location-form-number loc)) - (top-level-form + (toplevel-form (if cache-valid - (sfcache-top-level-form cache) - (get-top-level-form (sb!di:code-location-debug-source loc) + (sfcache-toplevel-form cache) + (get-toplevel-form (sb!di:code-location-debug-source loc) tlf-index))) (mapping-table (if cache-valid (sfcache-form-number-mapping-table cache) - (sb!di:form-number-translations top-level-form tlf-index)))) + (sb!di:form-number-translations toplevel-form tlf-index)))) (when (and (not cache-valid) cache) (setf (sfcache-debug-source cache) (sb!di:code-location-debug-source loc) - (sfcache-top-level-form-index cache) tlf-index - (sfcache-top-level-form cache) top-level-form + (sfcache-toplevel-form-index cache) tlf-index + (sfcache-toplevel-form cache) toplevel-form (sfcache-form-number-mapping-table cache) mapping-table)) - (cond ((null top-level-form) + (cond ((null toplevel-form) nil) ((> form-number (length mapping-table)) (warn "bogus form-number in form! The source file has probably ~@ been changed too much to cope with.") (when cache ;; Disable future warnings. - (setf (sfcache-top-level-form cache) nil)) + (setf (sfcache-toplevel-form cache) nil)) nil) (t (when cache (setf (sfcache-last-location-retrieved cache) loc) (setf (sfcache-last-form-retrieved cache) form-number)) - (sb!di:source-path-context top-level-form + (sb!di:source-path-context toplevel-form (aref mapping-table form-number) context))))) @@ -1068,9 +1077,9 @@ ;;;; stuff to use debugging-info to augment the disassembly -(defun code-function-map (code) +(defun code-fun-map (code) (declare (type sb!kernel:code-component code)) - (sb!di::get-debug-info-function-map (sb!kernel:%code-debug-info code))) + (sb!di::get-debug-info-fun-map (sb!kernel:%code-debug-info code))) (defstruct (location-group (:copier nil)) (locations #() :type (vector (or list fixnum)))) @@ -1144,13 +1153,13 @@ new)) ;;; Return a STORAGE-INFO struction describing the object-to-source -;;; variable mappings from DEBUG-FUNCTION. -(defun storage-info-for-debug-function (debug-function) - (declare (type sb!di:debug-function debug-function)) +;;; variable mappings from DEBUG-FUN. +(defun storage-info-for-debug-fun (debug-fun) + (declare (type sb!di:debug-fun debug-fun)) (let ((sc-vec sb!c::*backend-sc-numbers*) (groups nil) - (debug-vars (sb!di::debug-function-debug-vars - debug-function))) + (debug-vars (sb!di::debug-fun-debug-vars + debug-fun))) (and debug-vars (dotimes (debug-var-offset (length debug-vars) @@ -1198,9 +1207,9 @@ ))))))) ))) -(defun source-available-p (debug-function) +(defun source-available-p (debug-fun) (handler-case - (sb!di:do-debug-function-blocks (block debug-function) + (sb!di:do-debug-fun-blocks (block debug-fun) (declare (ignore block)) (return t)) (sb!di:no-debug-blocks () nil))) @@ -1217,9 +1226,9 @@ ;;; disassembly. SFCACHE can be either NIL or it can be a ;;; SOURCE-FORM-CACHE structure, in which case it is used to cache ;;; forms from files. -(defun add-source-tracking-hooks (segment debug-function &optional sfcache) +(defun add-source-tracking-hooks (segment debug-fun &optional sfcache) (declare (type segment segment) - (type (or null sb!di:debug-function) debug-function) + (type (or null sb!di:debug-fun) debug-fun) (type (or null source-form-cache) sfcache)) (let ((last-block-pc -1)) (flet ((add-hook (pc fun &optional before-address) @@ -1229,7 +1238,7 @@ :before-address before-address) (seg-hooks segment)))) (handler-case - (sb!di:do-debug-function-blocks (block debug-function) + (sb!di:do-debug-fun-blocks (block debug-fun) (let ((first-location-in-block-p t)) (sb!di:do-debug-block-locations (loc block) (let ((pc (sb!di::compiled-code-location-pc loc))) @@ -1285,12 +1294,12 @@ )))) (sb!di:no-debug-blocks () nil))))) -(defun add-debugging-hooks (segment debug-function &optional sfcache) - (when debug-function +(defun add-debugging-hooks (segment debug-fun &optional sfcache) + (when debug-fun (setf (seg-storage-info segment) - (storage-info-for-debug-function debug-function)) - (add-source-tracking-hooks segment debug-function sfcache) - (let ((kind (sb!di:debug-function-kind debug-function))) + (storage-info-for-debug-fun debug-fun)) + (add-source-tracking-hooks segment debug-fun sfcache) + (let ((kind (sb!di:debug-fun-kind debug-fun))) (flet ((anh (n) (push (make-offs-hook :offset 0 @@ -1311,38 +1320,38 @@ (defun get-function-segments (function) (declare (type compiled-function function)) (let* ((code (fun-code function)) - (function-map (code-function-map code)) - (fname (sb!kernel:%function-name function)) + (fun-map (code-fun-map code)) + (fname (sb!kernel:%simple-fun-name function)) (sfcache (make-source-form-cache))) (let ((first-block-seen-p nil) (nil-block-seen-p nil) (last-offset 0) - (last-debug-function nil) + (last-debug-fun nil) (segments nil)) (flet ((add-seg (offs len df) (when (> len 0) (push (make-code-segment code offs len - :debug-function df + :debug-fun df :source-form-cache sfcache) segments)))) - (dotimes (fmap-index (length function-map)) - (let ((fmap-entry (aref function-map fmap-index))) + (dotimes (fmap-index (length fun-map)) + (let ((fmap-entry (aref fun-map fmap-index))) (etypecase fmap-entry (integer (when first-block-seen-p (add-seg last-offset (- fmap-entry last-offset) - last-debug-function) - (setf last-debug-function nil)) + last-debug-fun) + (setf last-debug-fun nil)) (setf last-offset fmap-entry)) - (sb!c::compiled-debug-function - (let ((name (sb!c::compiled-debug-function-name fmap-entry)) - (kind (sb!c::compiled-debug-function-kind fmap-entry))) + (sb!c::compiled-debug-fun + (let ((name (sb!c::compiled-debug-fun-name fmap-entry)) + (kind (sb!c::compiled-debug-fun-kind fmap-entry))) #+nil (format t ";;; SAW ~S ~S ~S,~S ~D,~D~%" name kind first-block-seen-p nil-block-seen-p last-offset - (sb!c::compiled-debug-function-start-pc fmap-entry)) + (sb!c::compiled-debug-fun-start-pc fmap-entry)) (cond (#+nil (eq last-offset fun-offset) (and (equal name fname) (not first-block-seen-p)) (setf first-block-seen-p t)) @@ -1354,17 +1363,18 @@ (return)) (when first-block-seen-p (setf nil-block-seen-p t)))) - (setf last-debug-function - (sb!di::make-compiled-debug-function fmap-entry code)) + (setf last-debug-fun + (sb!di::make-compiled-debug-fun fmap-entry code)) ))))) (let ((max-offset (code-inst-area-length code))) - (when (and first-block-seen-p last-debug-function) + (when (and first-block-seen-p last-debug-fun) (add-seg last-offset (- max-offset last-offset) - last-debug-function)) + last-debug-fun)) (if (null segments) (let ((offs (fun-insts-offset function))) - (make-code-segment code offs (- max-offset offs))) + (list + (make-code-segment code offs (- max-offset offs)))) (nreverse segments))))))) ;;; Return a list of the segments of memory containing machine code @@ -1380,10 +1390,10 @@ (type length length)) (let ((segments nil)) (when code - (let ((function-map (code-function-map code)) + (let ((fun-map (code-fun-map code)) (sfcache (make-source-form-cache))) (let ((last-offset 0) - (last-debug-function nil)) + (last-debug-fun nil)) (flet ((add-seg (offs len df) (let* ((restricted-offs (min (max start-offset offs) @@ -1395,25 +1405,25 @@ (when (> restricted-len 0) (push (make-code-segment code restricted-offs restricted-len - :debug-function df + :debug-fun df :source-form-cache sfcache) segments))))) - (dotimes (fmap-index (length function-map)) - (let ((fmap-entry (aref function-map fmap-index))) - (etypecase fmap-entry + (dotimes (fun-map-index (length fun-map)) + (let ((fun-map-entry (aref fun-map fun-map-index))) + (etypecase fun-map-entry (integer - (add-seg last-offset (- fmap-entry last-offset) - last-debug-function) - (setf last-debug-function nil) - (setf last-offset fmap-entry)) - (sb!c::compiled-debug-function - (setf last-debug-function - (sb!di::make-compiled-debug-function fmap-entry - code)))))) - (when last-debug-function + (add-seg last-offset (- fun-map-entry last-offset) + last-debug-fun) + (setf last-debug-fun nil) + (setf last-offset fun-map-entry)) + (sb!c::compiled-debug-fun + (setf last-debug-fun + (sb!di::make-compiled-debug-fun fun-map-entry + code)))))) + (when last-debug-fun (add-seg last-offset (- (code-inst-area-length code) last-offset) - last-debug-function)))))) + last-debug-fun)))))) (if (null segments) (make-code-segment code start-offset length) (nreverse segments)))) @@ -1492,7 +1502,7 @@ (dolist (seg segments) (disassemble-segment seg stream dstate))))) -;;;; top-level functions +;;;; top level functions ;;; Disassemble the machine code instructions for FUNCTION. (defun disassemble-function (function &key @@ -1521,12 +1531,10 @@ (and (listp thing) (eq (car thing) 'setf))) (compiled-function-or-lose (fdefinition thing) thing)) - ((sb!eval:interpreted-function-p thing) - (compile-function-lambda-expr thing)) ((functionp thing) thing) ((and (listp thing) - (eq (car thing) 'sb!impl::lambda)) + (eq (car thing) 'lambda)) (compile nil thing)) (t (error "can't make a compiled function from ~S" name)))) @@ -1535,7 +1543,7 @@ (stream *standard-output*) (use-labels t)) #!+sb-doc - "Disassemble the machine code associated with OBJECT, which can be a + "Disassemble the compiled code associated with OBJECT, which can be a function, a lambda expression, or a symbol with a function definition. If it is not already compiled, the compiler is called to produce something to disassemble." @@ -1543,14 +1551,10 @@ (type (or (member t) stream) stream) (type (member t nil) use-labels)) (pprint-logical-block (*standard-output* nil :per-line-prefix "; ") - (let ((fun (compiled-function-or-lose object))) - (if (typep fun 'sb!kernel:byte-function) - (sb!c:disassem-byte-fun fun) - ;; We can't detect closures, so be careful. - (disassemble-function (fun-self fun) - :stream stream - :use-labels use-labels))) - nil)) + (disassemble-function (compiled-function-or-lose object) + :stream stream + :use-labels use-labels) + nil)) ;;; Disassembles the given area of memory starting at ADDRESS and ;;; LENGTH long. Note that if CODE-COMPONENT is NIL and this memory @@ -1615,15 +1619,11 @@ ;;; not just 4 on a risc machine! (defconstant max-instruction-size 16) -(defun sap-to-vector (sap start end) - (let* ((length (- end start)) - (result (make-array length :element-type '(unsigned-byte 8))) - (sap (sb!sys:sap+ sap start))) - (dotimes (i length) - (setf (aref result i) (sb!sys:sap-ref-8 sap i))) - result)) - -(defun add-block-segments (sap amount seglist location connecting-vec dstate) +(defun add-block-segments (seg-code-block + seglist + location + connecting-vec + dstate) (declare (type list seglist) (type integer location) (type (or null (vector (unsigned-byte 8))) connecting-vec) @@ -1634,25 +1634,27 @@ (setf (seg-length seg) length) (incf location length) (push seg seglist))))) - (let ((connecting-overflow 0)) + (let ((connecting-overflow 0) + (amount (length seg-code-block))) (when connecting-vec ;; Tack on some of the new block to the old overflow vector. (let* ((beginning-of-block-amount - (if sap (min max-instruction-size amount) 0)) + (if seg-code-block (min max-instruction-size amount) 0)) (connecting-vec - (if sap + (if seg-code-block (concatenate '(vector (unsigned-byte 8)) connecting-vec - (sap-to-vector sap 0 beginning-of-block-amount)) + (subseq seg-code-block 0 beginning-of-block-amount)) connecting-vec))) (when (and (< (length connecting-vec) max-instruction-size) - (not (null sap))) + (not (null seg-code-block))) (return-from add-block-segments ;; We want connecting vectors to be large enough to hold - ;; any instruction, and since the current sap wasn't large - ;; enough to do this (and is now entirely on the end of the - ;; overflow-vector), just save it for next time. + ;; any instruction, and since the current seg-code-block + ;; wasn't large enough to do this (and is now entirely + ;; on the end of the overflow-vector), just save it for + ;; next time. (values seglist location connecting-vec))) (when (> (length connecting-vec) 0) (let ((seg @@ -1663,7 +1665,7 @@ :virtual-location location))) (setf connecting-overflow (segment-overflow seg dstate)) (addit seg connecting-overflow))))) - (cond ((null sap) + (cond ((null seg-code-block) ;; nothing more to add (values seglist location nil)) ((< (- amount connecting-overflow) max-instruction-size) @@ -1672,25 +1674,25 @@ ;; in the overflow vector for the time-being. (values seglist location - (sap-to-vector sap connecting-overflow amount))) + (subseq seg-code-block connecting-overflow amount))) (t ;; Put as much as we can into a new segment, and the rest ;; into the overflow-vector. (let* ((initial-length (- amount connecting-overflow max-instruction-size)) (seg - (make-segment (lambda () - (sb!sys:sap+ sap connecting-overflow)) - initial-length - :virtual-location location)) + (make-vector-segment seg-code-block + connecting-overflow + initial-length + :virtual-location location)) (overflow (segment-overflow seg dstate))) (addit seg overflow) (values seglist location - (sap-to-vector sap - (+ connecting-overflow (seg-length seg)) - amount)))))))) + (subseq seg-code-block + (+ connecting-overflow (seg-length seg)) + amount)))))))) ;;;; code to disassemble assembler segments @@ -1700,31 +1702,26 @@ (let ((location 0) (disassem-segments nil) (connecting-vec nil)) - (error "stub: code not converted to new SEGMENT WHN 19990322" ; KLUDGE - assem-segment) ; (to avoid "ASSEM-SEGMENT defined but never used") - ;; old code, needs to be converted to use less-SAPpy ASSEM-SEGMENTs: - #|(sb!assem:segment-map-output + (sb!assem:on-segment-contents-vectorly assem-segment - (lambda (sap amount) + (lambda (seg-code-block) (multiple-value-setq (disassem-segments location connecting-vec) - (add-block-segments sap amount - disassem-segments location + (add-block-segments seg-code-block + disassem-segments + location connecting-vec - dstate))))|# + dstate)))) (when connecting-vec (setf disassem-segments - (add-block-segments nil nil - disassem-segments location + (add-block-segments nil + disassem-segments + location connecting-vec dstate))) (sort disassem-segments #'< :key #'seg-virtual-location))) -;;; FIXME: I noticed that this is only called by #!+SB-SHOW code. It would -;;; be good to see whether this is the only caller of any other functions. -;;; ;;; Disassemble the machine code instructions associated with ;;; ASSEM-SEGMENT (of type assem:segment). -#!+sb-show (defun disassemble-assem-segment (assem-segment stream) (declare (type sb!assem:segment assem-segment) (type stream stream)) @@ -1736,7 +1733,7 @@ ;;; routines to find things in the Lisp environment -;;; an alist of (SYMBOL-SLOT-OFFSET . ACCESS-FUNCTION-NAME) for slots +;;; an alist of (SYMBOL-SLOT-OFFSET . ACCESS-FUN-NAME) for slots ;;; in a symbol object that we know about (defparameter *grokked-symbol-slots* (sort `((,sb!vm:symbol-value-slot . symbol-value) @@ -1752,7 +1749,7 @@ ;;; access function of the slot. (defun grok-symbol-slot-ref (address) (declare (type address address)) - (if (not (aligned-p address sb!vm:word-bytes)) + (if (not (aligned-p address sb!vm:n-word-bytes)) (values nil nil) (do ((slots-tail *grokked-symbol-slots* (cdr slots-tail))) ((null slots-tail) @@ -1762,7 +1759,7 @@ (maybe-symbol-addr (- address slot-offset)) (maybe-symbol (sb!kernel:make-lisp-obj - (+ maybe-symbol-addr sb!vm:other-pointer-type)))) + (+ maybe-symbol-addr sb!vm:other-pointer-lowtag)))) (when (symbolp maybe-symbol) (return (values maybe-symbol (cdr field)))))))) @@ -1793,7 +1790,7 @@ (values (sb!kernel:code-header-ref code (ash (+ byte-offset - sb!vm:other-pointer-type) + sb!vm:other-pointer-lowtag) (- sb!vm:word-shift))) t) (values nil nil)))) @@ -1807,7 +1804,7 @@ (let ((code-size (ash (sb!kernel:get-header-data code) sb!vm:word-shift))) (sb!sys:without-gcing (let ((code-addr (- (sb!kernel:get-lisp-obj-address code) - sb!vm:other-pointer-type))) + sb!vm:other-pointer-lowtag))) (if (or (< addr code-addr) (>= addr (+ code-addr code-size))) (values nil nil) (values (sb!kernel:code-header-ref @@ -1832,9 +1829,9 @@ (declare (type address address)) (when (null *assembler-routines-by-addr*) (setf *assembler-routines-by-addr* - (invert-address-hash sb!kernel::*assembler-routines*)) + (invert-address-hash sb!fasl:*assembler-routines*)) (setf *assembler-routines-by-addr* - (invert-address-hash sb!kernel::*static-foreign-symbols* + (invert-address-hash sb!fasl:*static-foreign-symbols* *assembler-routines-by-addr*))) (gethash address *assembler-routines-by-addr*))