;;; <padding to dual-word boundary>
;;; 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
;;; <padding to dual-word boundary>
\f
(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)
(def!method print-object ((seg segment) stream)
(print-unreadable-object (seg stream :type t)
(let ((addr (sb!sys:sap-int (funcall (seg-sap-maker seg)))))
- (format stream "#X~X[~D]~:[ (#X~X)~;~*~]~@[ in ~S~]"
+ (format stream "#X~X[~W]~:[ (#X~X)~;~*~]~@[ in ~S~]"
addr
(seg-length seg)
(= (seg-virtual-location seg) addr)
(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
- "+~D~@[ in ~S~]"
+ "+~W~@[ in ~S~]"
(dstate-cur-offs dstate)
(dstate-segment dstate))))
(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
(declare (type sb!kernel:code-component code-component))
(sb!sys:sap-int (sb!kernel:code-instructions code-component)))
+;;; unused as of sbcl-0.pre7.129
+#|
;;; Return the first function in CODE-COMPONENT.
(defun code-first-function (code-component)
(declare (type sb!kernel:code-component code-component))
(sb!kernel:code-header-ref code-component
sb!vm:code-trace-table-offset-slot))
+|#
(defun segment-offs-to-code-offs (offset segment)
(sb!sys:without-gcing
(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)
(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)
(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)))
\f
(defun alignment-hook (chunk stream dstate)
(declare (type dchunk chunk)
(alignment (dstate-alignment dstate)))
(unless (aligned-p location alignment)
(when stream
- (format stream "~A~Vt~D~%" '.align
+ (format stream "~A~Vt~W~%" '.align
(dstate-argument-column dstate)
alignment))
(incf(dstate-next-offs dstate)
(not (offs-hook-before-address next-hook))))
(return))
(unless (< hook-offs cur-offs)
- (funcall (offs-hook-function next-hook) stream dstate))
+ (funcall (offs-hook-fun next-hook) stream dstate))
(pop (dstate-cur-offs-hooks dstate))
(unless (= (dstate-next-offs dstate) cur-offs)
(return)))))))
(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)
(incf max)
(setf (cdr label) max)
(setf (gethash (car label) label-hash)
- (format nil "L~D" max)))))
+ (format nil "L~W" max)))))
(setf (dstate-labels dstate) labels))))
\f
;;; Get the instruction-space, creating it if necessary.
(when (or (null label-location) (> label-location location))
(return))
(unless (< label-location location)
- (format stream " L~D:" (cdr next-label)))
+ (format stream " L~W:" (cdr next-label)))
(pop (dstate-cur-labels dstate))))
;; move to the instruction column
(string
(write-string note stream))
(function
- (funcall note stream))))
+ (funcall note stream))))
(terpri stream))
(fresh-line stream)
(setf (dstate-notes dstate) nil)))
(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)))))
\f
(defvar *default-dstate-hooks* (list #'lra-hook))
;;; 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
(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))
(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
(let ((fun-offset (sb!kernel:get-closure-length fun)))
;; There is function header fun-offset words from the
;; code header.
- (format t "Fun-header ~S at offset ~D (words): ~S~A => ~S~%"
+ (format t "Fun-header ~S at offset ~W (words): ~S~A => ~S~%"
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)))))))
\f
;;; 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
(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)))))
(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)))))
(values nil nil)
(values (get-source-form loc context cache) t)))
\f
-;;;; stuff to use debugging-info to augment the disassembly
+;;;; 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!c::compiled-debug-info-fun-map (sb!kernel:%code-debug-info code)))
(defstruct (location-group (:copier nil))
(locations #() :type (vector (or list fixnum))))
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)
:debug-vars debug-vars))
(let ((debug-var (aref debug-vars debug-var-offset)))
#+nil
- (format t ";;; At offset ~D: ~S~%" debug-var-offset debug-var)
+ (format t ";;; At offset ~W: ~S~%" debug-var-offset debug-var)
(let* ((sc-offset
(sb!di::compiled-debug-var-sc-offset debug-var))
(sb-name
(sb!c:sc-sb (aref sc-vec
(sb!c:sc-offset-scn sc-offset))))))
#+nil
- (format t ";;; SET: ~S[~D]~%"
+ (format t ";;; SET: ~S[~W]~%"
sb-name (sb!c:sc-offset-offset sc-offset))
(unless (null sb-name)
(let ((group (cdr (assoc sb-name groups))))
)))))))
)))
-(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)))
;;; 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)
: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)))
(when stream
(unless at-block-begin
(terpri stream))
- (format stream ";;; [~D] "
+ (format stream ";;; [~W] "
(sb!di:code-location-form-number
loc))
(prin1-short form stream)
))))
(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
\f
;;; Return a list of the segments of memory containing machine code
;;; instructions for FUNCTION.
-(defun get-function-segments (function)
+(defun get-fun-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~%"
+ (format t ";;; SAW ~S ~S ~S,~S ~W,~W~%"
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))
(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
(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)
(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))))
(dolist (seg segments)
(disassemble-segment seg stream dstate)))))
\f
-;;;; top-level functions
+;;;; top level functions
;;; Disassemble the machine code instructions for FUNCTION.
-(defun disassemble-function (function &key
- (stream *standard-output*)
- (use-labels t))
- (declare (type compiled-function function)
+(defun disassemble-fun (fun &key
+ (stream *standard-output*)
+ (use-labels t))
+ (declare (type compiled-function fun)
(type stream stream)
(type (member t nil) use-labels))
(let* ((dstate (make-dstate))
- (segments (get-function-segments function)))
+ (segments (get-fun-segments fun)))
(when use-labels
(label-segments segments dstate))
(disassemble-segments segments stream dstate)))
+;;; FIXME: We probably don't need this any more now that there are
+;;; no interpreted functions, only compiled ones.
(defun compile-function-lambda-expr (function)
(declare (type function function))
(multiple-value-bind (lambda closurep name)
(error "can't compile a lexical closure"))
(compile nil lambda)))
-(defun compiled-function-or-lose (thing &optional (name thing))
+(defun compiled-fun-or-lose (thing &optional (name thing))
(cond ((or (symbolp thing)
(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))
+ (compiled-fun-or-lose (fdefinition thing) 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))))
(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."
(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-fun (compiled-fun-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
;;; 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)
(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
: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)
;; 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))))))))
\f
;;;; code to disassemble assembler segments
(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))
\f
;;; 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)
;;; 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)
(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))))))))
(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))))
(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
(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*))
\f