(sort insts #'> :key #'specializer-rank))
(defun specialization-error (insts)
- (error "~@<internal disassembler error: ~2I~_Instructions either aren't related or conflict in some way: ~4I~_~S~:>"
- insts))
+ (bug
+ "~@<Instructions either aren't related or conflict in some way: ~4I~_~S~:>"
+ insts))
;;; Given a list of instructions INSTS, Sees if one of these instructions is a
;;; more general form of all the others, in which case they are put into its
;;; <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)
+ (fun (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)
;; offset of next position
(next-offs 0 :type offset)
;; a sap pointing to our segment
- (segment-sap (required-argument) :type sb!sys:system-area-pointer)
+ (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
(fun-hooks nil :type list)
;; 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-labels nil :type list)
+ ;; OFFS-HOOKs, popped as they're used
(cur-offs-hooks nil :type list)
;; for the current location
(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))))
(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
(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)
(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)
(setf (dstate-cur-offs dstate) 0)
(setf (dstate-cur-labels dstate) (dstate-labels dstate)))
-(defun do-offs-hooks (before-address stream dstate)
+(defun call-offs-hooks (before-address stream dstate)
(declare (type (or null stream) stream)
(type disassem-state dstate))
(let ((cur-offs (dstate-cur-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)))))))
-(defun do-fun-hooks (chunk stream dstate)
+(defun call-fun-hooks (chunk stream dstate)
(let ((hooks (dstate-fun-hooks dstate))
(cur-offs (dstate-cur-offs dstate)))
(setf (dstate-next-offs dstate) cur-offs)
(setf (dstate-next-offs dstate) (dstate-cur-offs dstate))
- (do-offs-hooks t stream dstate)
+ (call-offs-hooks t stream dstate)
(unless (or prefix-p (null stream))
(print-current-address stream dstate))
- (do-offs-hooks nil stream dstate)
+ (call-offs-hooks nil stream dstate)
(unless (> (dstate-next-offs dstate) (dstate-cur-offs dstate))
(sb!sys:without-gcing
(sap-ref-dchunk (dstate-segment-sap dstate)
(dstate-cur-offs dstate)
(dstate-byte-order dstate))))
- (let ((fun-prefix-p (do-fun-hooks chunk stream dstate)))
+ (let ((fun-prefix-p (call-fun-hooks chunk stream dstate)))
(if (> (dstate-next-offs dstate) (dstate-cur-offs dstate))
(setf prefix-p fun-prefix-p)
(let ((inst (find-inst chunk ispace)))
(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
((null fun))
(let ((offset (code-offs-to-segment-offs (fun-offset fun) segment)))
(when (<= 0 offset length)
- (push (make-offs-hook :offset offset :function #'fun-header-hook)
+ (push (make-offs-hook :offset offset :fun #'fun-header-hook)
(seg-hooks segment))))))
\f
;;; A SAP-MAKER is a no-argument function that returns a SAP.
(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
(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-fun-map (code)
(declare (type sb!kernel:code-component code))
- (sb!di::get-debug-info-fun-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))))
: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))))
(let ((last-block-pc -1))
(flet ((add-hook (pc fun &optional before-address)
(push (make-offs-hook
- :offset pc ;; ##### FIX to account for non-zero offs in code
- :function fun
+ :offset pc ;; ### FIX to account for non-zero offs in code
+ :fun fun
:before-address before-address)
(seg-hooks segment))))
(handler-case
(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)
(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)
+ (flet ((add-new-hook (n)
(push (make-offs-hook
:offset 0
- :function (lambda (stream dstate)
- (declare (ignore stream))
- (note n dstate)))
+ :fun (lambda (stream dstate)
+ (declare (ignore stream))
+ (note n dstate)))
(seg-hooks segment))))
(case kind
(:external)
((nil)
- (anh "no-arg-parsing entry point"))
+ (add-new-hook "no-arg-parsing entry point"))
(t
- (anh (lambda (stream)
- (format stream "~S entry point" kind)))))))))
+ (add-new-hook (lambda (stream)
+ (format stream "~S entry point" kind)))))))))
\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))
(fun-map (code-fun-map code))
(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-fun-start-pc fmap-entry))
(when first-block-seen-p
(setf nil-block-seen-p t))))
(setf last-debug-fun
- (sb!di::make-compiled-debug-fun fmap-entry code))
- )))))
+ (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-fun)
(add-seg last-offset
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
(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))
+ (compiled-fun-or-lose (fdefinition thing) thing))
((functionp thing)
thing)
((and (listp thing)
(type (or (member t) stream) stream)
(type (member t nil) use-labels))
(pprint-logical-block (*standard-output* nil :per-line-prefix "; ")
- (disassemble-function (compiled-function-or-lose object)
- :stream stream
- :use-labels use-labels)
+ (disassemble-fun (compiled-fun-or-lose object)
+ :stream stream
+ :use-labels use-labels)
nil))
;;; Disassembles the given area of memory starting at ADDRESS and
projects / sbcl.git / blobdiff